WSO2 API

Een WSO2 API Manager opzetten in Docker (deel1)

Rob Blaauboer
Senior Business Consultant
Scroll

Het installeren van een WSO2 API Manager (APIM), of eigenlijk ieder WSO2 product, is een fluitje van een cent. We hebben gedetailleerde stappen beschreven in die blog. Maar het afgelopen half jaar springt Docker er steeds vaker uit als de nieuwe omgeving waarin WSO2 producten gedraaid worden.

Om deze blog toegankelijker te maken voor een breder publiek zullen we het eerst hebben over wat Docker is. Daarna duiken we in het diepe over hoe je in Docker WSO2 API Manager op kunt bouwen.

Docker in het kort

Docker is niets anders dan een nieuwe maner om digitale omgevingen te virtualiseren.

Een traditionele computeromgeving ziet eruit als het onderstaande voorbeeld:

Zoals je ziet is het besturingssysteem (OS) geïnstalleerd op de hardware (dat is inclusief alle drivers, geheugen en processoren). Bovenop het besturingssysteem ligt de applicatielaag (waarin verschillende applicaties draaien). Het voorbeeld laat zien wat je op jouw eigen pc zou kunnen installeren om APIM te runnen.

Wanneer je virtualisatiesoftware zoals VMWare of VirtualBox runt, ligt het net wat anders.

De onderste lagen zijn hetzelfde als je een lokale versie draait, maar als je er een virtualisatielaag ertussen legt, krijg je de mogelijkheid om een gecombineerde set van zowel de OS en Applicaties te runnen. Dat wordt een virtueel apparaat genoemd. Hierdoor kun tegelijkertijd van verschillende smaken aan omgevingen genieten, bijvoorbeeld door APIM op CentOS en ESB op SUSE te draaien. Een virtueel apparaat omvat echter wel het besturingssysteem én alle applicaties.

Docker is daarentegen een hybride versie. Het lijkt erg veel op een lokale PC-omgeving, omdat er geen virtualisatiesoftware zichtbaar is. Tegelijkertijd vertoont Docker een sterke gelijkenis met virtuele apparaten en traditionele virtualisatieomgevingen. Een ‘Docker Image’ kan vervolgens zo opgebouwd worden dat het Java, WSO2 en alle andere software bevat die nodig is om APIM te runnen.

Een Dockeromgeving instellen

Natuurlijk zullen we Docker moeten installeren op onze computer. Omdat Docker op Linux draait (met andere woorden: het gebruikt Linux commando’s) werkt Docker niet op 1-op-1 op Windows. Zelf gebruik ik Windows, dus zal ik in dit voorbeeld een virtuele machine (VM) moeten maken die op Linux draait.

Ik kies ervoor om Vagrant te gebruiken. Vagrant is een tool die me niet alleen een VirtualBox met Linux laten starten, maar daar ook al Docker en alle andere dingen op geïnstalleerd heeft staan.

Het installeren van vagrant

Om het hier kort en bondig te houden, verwijs ik naar deze blog voor de installatie instructies voor Vagrant.

Wanneer een Vagrantomgeving geïnstalleerd is, kun je de commandoregel van je systeem gebruiken en een map aanmaken voor de Vagrant bestanden. Ik doe het als volgt:

md vagrant
cd vagrant
md docker
cd docker
Vanuit de map waar ik Vagrant geïnitialiseerd heb gebruik ik:
vagrant init

Dit zal een Vagrantfile aanmaken waarin de VM die we gaan gebruiken beschreven wordt. Verander de default settings (ik laat alleen de veranderingen zien) om een geschikte VM te creëren. Houd er rekening mee dat ik ervan uitga dat je alles geïnstalleerd hebt zoals beschreven staat in de blog waar ik eerder naar verwees.

De volgende parameters zul je moeten aanpassen:

Vagrant.configure("2") do |config|
  ENV["LC_ALL"] = "en_US.UTF-8"
  config.vm.box = "centos/7"
  config.vm.box_check_update = false
config.vm.define "Yenlo Docker" do |machine|
    machine.vm.hostname = "centosdocker"   
    machine.vm.provider "virtualbox" do |vb|
      vb.name = "YENLO Docker 1.0"
      vb.memory = "4096"
    end
    machine.vm.network "private_network", ip: "192.168.33.77"
end
config.vm.provision "shell", inline: <<-SHELL
#HERE WE WILL PUT THE SHELL COMMANDS TO INSTALL DOCKER
  SHELL
end

Wanneer alle veranderingen aan de Vagrantfile gemaakt zijn, kunnen we het volgende commando uitvoeren:

vagrant up

Hierdoor wordt de omgeving aangemaakt die we gebruiken om Docker te installeren. Alle commando’s die je invoert staan ook in een Vagrantfile die het proces automatisch zal afronden. Het is aan te raden om de instructies in de blog te volgen, zodat je beter begrijpt hoe Docker werkt. Daarna kun je de Vagrantfile naar hartenlust gebruiken en wijzigen. De Vagrantfile van deze blog kun je hier downloaden.

Vagrant SSH

Om Docker te installeren benutten we een Secure Shell (SSH) om het in de zojuist aangemaakte machine te implementeren, daarvoor gebruiken we het commando:

vagrant ssh

Typ het volgende op de command line:

sudo yum install -y docker

Dit zorgt voor de installatie van Docker. Dit kun je vervolgens testen met:

docker -v

wat de versie van de geïnstalleerde Docker teruggeeft.

Zorg ervoor dat Docker daemon gerund wordt met dit commando:

sudo service docker start

Een andere test is daadwerkelijk een Docker Image in een zogenoemde container te runnen. Dit kun je doen door het volgende commando in te voeren:

sudo docker run hello-world

Zoals in de afbeelding te zien is, wordt daarbij ook uitgelegd hoe Docker werkt:

  1. De command line vertelt Docker een specifieke Docker image te runnen
  2. De docker-deamon haalt de afbeelding uit de Docker Hub
  3. De docker-deamon maakt een container aan met de opgehaalde afbeelding
  4. De docker-deamon laat de output zien op de command line

Docker Builder

Om een Docker API Manager Library te bouwen hebben we nog meer nodig. Er zijn natuurlijk versies beschikbaar in de Docker Hub, maar het is beter om onze eigen image te bouwen.

Als we een ‘distributed deployment’ willen, bijv. WSO2 API Manager componenten in verschillende containers, zullen we ook Docker Compose moeten installeren. Hoewel we geen volledige distributed deployment op het oog hebben, zijn de WSO2 Dockerfiles die voorheen beschikbaar waren nu verdwenen. Maar we zullen toch laten zien hoe je Docker Compose kunt installeren. De WSO2 Dockerfiles bevatten ook een Docker Compose set aan bestanden. Dit leggen we uit in een volgende blog.

Voor nu installeren we python-pip om te voldoen aan de randvoorwaarden:

  • sudo yum install -y epel-release
  • sudo yum install -y python-pip

Daarna kunnen we Docker Compose installeren:

  • sudo pip install docker-compose

Je zult nu ook je Python packages moeten upgraden op CentOS 7 om Docker Compose probleemloos te kunnen runnen:

  • sudo yum upgrade -y python*

Tot slot installeren we unzip en wget:

sudo yum install -y unzip
sudo yum install -y wget

en downloaden we de WSO2 API Manager Dockerfiles van GitHub.

wget https://github.com/wso2/docker-apim/archive/master.zip

Nu unzippen we het gedownloade zip-bestand met:

sudo unzip master -d /opt

en hebben de volgende structuur om onze Docker image te vormen. We zullen verwijzen naar /opt/docker-apim-master als [Docker-Home] locatie.

Wat staat er in de Dockerfile?

Als we kijken naar de Dockerfile, dan vinden verschillende secties:

  • Instellingen met betrekking tot de container: zoals User, User Group, JAVA_HOME enz.
  • Installeer de containerbestanden: Debian, curl, iproute2, telnet, unzip
  • Een usergroup en user aanmaken
  • Kopieer de bestanden in de /files map naar de
  • Installeren van de vereiste pakketten (JDK naar de user home map verplaatsen en unzippen)
  • Instellen van user en werkmap, omgevingen en verwijderen van onnodige bestanden, poorten openstellen en WSO2 opstarten

We maken kortom een speciale omgeving aan om WSO2 te runnen. In dit geval in Docker. Dat is alles.

# ------------------------------------------------------------------------
#
# Copyright 2017 WSO2, Inc. (http://wso2.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at|
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License
#
# ------------------------------------------------------------------------
# set to latest Ubuntu LTS
FROM ubuntu:16.04
MAINTAINER WSO2 Docker Maintainers dev@wso2.org
# set user configurations
ARG USER=wso2carbon
ARG USER_GROUP=wso2
ARG USER_HOME=/home/${USER}
# set dependant files directory
ARG FILES=./files
# set jdk configurations
ARG JDK_ARCHIVE=jdk-8u*-linux-x64.tar.gz
ARG JAVA_HOME=${USER_HOME}/java
# set wso2 product configurations
ARG WSO2_SERVER=wso2am
ARG WSO2_SERVER_VERSION=2.1.0
ARG WSO2_SERVER_PACK=${WSO2_SERVER}-${WSO2_SERVER_VERSION}.zip
ARG WSO2_SERVER_HOME=${USER_HOME}/${WSO2_SERVER}-${WSO2_SERVER_VERSION}

# install required packages
RUN apt-get update && \
	DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends --no-install-suggests \
	curl \
	iproute2 \
	telnet \
	unzip && \
	rm -rf /var/lib/apt/lists/*

# create a user group and a user
RUN groupadd --system ${USER_GROUP} && \
	useradd --system --create-home --home-dir ${USER_HOME} --no-log-init -g ${USER_GROUP} ${USER}
# copy the jdk and wso2 product distribution zip files to user's home directory
COPY ${FILES}/${JDK_ARCHIVE} ${FILES}/${WSO2_SERVER_PACK} ${USER_HOME}/

# install the jdk, wso2 server, remove distributions and set folder permissions
RUN mkdir -p ${JAVA_HOME} && \
	tar -xf ${USER_HOME}/${JDK_ARCHIVE} -C ${JAVA_HOME} --strip-components=1 && \
	unzip -q ${USER_HOME}/${WSO2_SERVER_PACK} -d ${USER_HOME}/ && \
	rm ${USER_HOME}/${JDK_ARCHIVE} && \
	rm ${USER_HOME}/${WSO2_SERVER_PACK} && \
	chown -R ${USER}:${USER_GROUP} ${USER_HOME} && \
	chmod -R g=u ${USER_HOME}
# set the user and work directory
USER ${USER}
WORKDIR ${USER_HOME}
# set environment variables
ENV JAVA_HOME=${JAVA_HOME} \
	PATH=$JAVA_HOME/bin:$PATH \
	WSO2_SERVER_HOME=${WSO2_SERVER_HOME}

# expose ports
EXPOSE 8280 8243 9763 9443 9099 5672 9711 9611 7711 7611 10397

ENTRYPOINT ${WSO2_SERVER_HOME}/bin/wso2server.sh

Om dit vervolgens allemaal te laten werken zullen we de bestanden naar de bestandsmap in de mapstructuur moeten kopiëren. In dit geval is dat de apim submap, omdat daar ook apim-anlytics aanwezig is.

Zo ziet de boom eruit:

├── docker-compose
│           	└── apim-analytics
│               ├── am-2.1.0-pattern-1.png
│               ├── am-analytics
│                            	└── carbon
│                                              	└── repository
│                                                                   ├── components
│                                                                                 	│   └── lib
│                                                               	└── conf
│                                                                                 	└── datasources
│                                                                                                      ├── analytics-datasources.xml
│                                                                                                  	└── stats-datasources.xml
│               ├── api-manager
│           	   └── carbon
│                            	└── repository
│                                                  ├── components
│                                              	│   └── lib
│                            	└── conf
│                                                  ├── api-manager.xml
│                                                  ├── carbon.xml
│                                                  ├── datasources
│                                              	│   └── master-datasources.xml
│                                              	└── tomcat
│                                                               	└── catalina-server.xml
│               ├── docker-compose.yml
│               ├── mysql
│           	              	└── scripts
│                                ├── apim_mysql5.7.sql
│                            	└── carbon_mysql5.7.sql
│           	└── README.md
├── dockerfiles
│               ├── apim
│                                ├── Dockerfile
│                                ├── files
│                            	│               ├── jdk-8u161-linux-x64.tar.gz
│                            	│           	└── wso2am-2.1.0.zip
│                            	└── README.md
│           	└── apim-analytics
│                                ├── Dockerfile
│                                ├── files
│                            	└── README.md
├── issue_template.md
├── LICENSE
├── pull_request_template.md
└── README.md

Om alles echt te laten werken zullen we de JDK en WSO2 APIM aan de Vagrantomgeving moeten toevoegen, zodat het vervolgens naar de Docker image overgezet kan worden.

Java 8 JDK toevoegen

We downloaden Oracle Java JDK 8 en voegen het aan de bestandsmap toe. Gebruik de Java SE Development Kit 8u161, omdat eerdere versies (151) problemen hadden met WSO2.

Je kunt het bestand hier downloaden.

Nadat je het bestand hebt binnengehaald, kopieer je het naar de [Docker-Home]/dockerfiles/apim/files map.

sudo cp jdk-8u161-linux-x64.tar.gz /opt/docker-apim-master/dockerfiles/apim/files

WSO2 API Manager toevoegen

Download de WSO2 API Manager 2.1.0 distribution (http://wso2.com/api-management/try-it/) en kopieer die naar [Docker-Home]/dockerfiles/apim/files .

De Docker image opbouwen

Navigeer naar de bestandsmap: [Docker-Home]/dockerfiles/apim.

Voer het commando: docker build uit zoals hieronder te zien is. Vergeet de ‘.’ (punt) aan het eind van het commando niet.

docker build -t wso2am:2.1.0 .

De Docker image runnen

Wanneer de Image gebouwd is, kunnen we deze runnen met:

docker run -it -p 9443:9443 wso2am:2.1.0

Toegang tot de managementconsole

Zoals je kunt zien aan de console output, runt de image in de Docker Container. Om toegang te krijgen tot de Management UI moeten we eerst bij de managementconsole komen. Omdat we een privénetwerk hebben gemaakt, kunnen we een browser van buiten de VirtualBox benutten om toegang te krijgen tot de Management UI. 

Om de bij de managementconsole te komen gebruiken we de Docker host IP en poort 9443.

https://192.168.33.77:9443/carbon

Docker, maar dan meer geavanceerd

Wat we nu hebben gedaan is een zo eenvoudig mogelijke Docker API Manager laten runnen in een VirtualBox. In de volgende blog gaan we kijken naar Docker Compose voor het opstarten van meerdere containers en het aanbrengen van wijzigingen aan onze Docker container.

Als je vragen hebt over deze blogpost, neem dan gerust contact met ons op via het commentaar hieronder. Bekijk ook onze WSO2 tutorials, webinars of white papers voor meer technische informatie. Ondersteuning nodig? Wij bieden WSO2 Productondersteuning, en ondersteuning voor WSO2 Development, WSO2 Operational en WSO2 Trainingsprogramma’s.