fb
API Management 9 Minuten

Einen WSO2 API-Manager im Dock einrichten (Teil 1)

Rob Blaauboer
Rob Blaauboer
Integration Consultant & WSO2 Trainer
Blog 6 1
Scrollen
Blog-6-1

Die Installation eines WSO2 API Managers (APIM), oder eines anderen WSO2-Produkts ist ein Kinderspiel. Wir haben die Schritte in diesem Blog ausführlich beschrieben. Seit etwa einem halben Jahr taucht jedoch immer wieder Docker als neue Oberfläche zur Ausführung von WSO2-Produkten auf! Um dieses Blog mehr Lesern zugänglich zu machen, sollten wir erst einmal darüber sprechen, was Docker ist, bevor wir erklären, wie man einen WSO2-API-Manager mit Docker einrichtet.

Banner-WSO2-Community-1-1

Docker 101

Docker ist nicht mehr und nicht weniger als eine neue Art der Virtualisierung von Umgebungen.

Eine herkömmliche Computerumgebung sieht in etwa so aus:

Blog-6-2

Wie du sehen kannst, wird das Betriebssystem auf der Hardware installiert (die alle Laufwerke, Speicher und Prozessoren umfasst). Auf dem Betriebssystem befindet sich die App-Ebene (auf der verschiedene Apps laufen). Das Beispiel zeigt, was du installieren könntest, um APIM auf deinem lokalen PC auszuführen.

Wenn du Virtualisierungssoftware wie VMWare oder VirtualBox ausführst, verändert sich das Bild leicht.

Blog-6-3

Die unteren Schichten sind die gleichen wie bei der lokalen Ausführung, du fügst jedoch eine Virtualisierungsebene hinzu, die es ermöglicht, ein gebündeltes Set auszuführen, welches sowohl das Betriebssystem als auch die Apps enthält, die so genannte virtuelle Appliance. Dadurch können Sie mehrere Umgebungsvarianten einsetzen, z. B. APIM unter CentOS und ESB unter SUSE. Jedoch enthält jede virtuelle Appliance sowohl das Betriebssystem als auch alle Apps.

Docker hingegen ist ein Hybrid. Es ähnelt sehr stark einer lokalen PC-Umgebung, da keine Virtualisierungssoftware sichtbar ist. Zugleich hat Docker etwas Ähnliches wie die virtuellen Appliances der traditionellen Virtualisierungsumgebungen. Ein Docker-Image kann so erstellt werden, dass es Java, WSO2 und alle andere zur Ausführung von APIM erforderliche Software enthält.

Blog-6-4

Einrichtung der Docker-Umgebung

Natürlich müssen wir Docker auf unserem Computer installieren. Weil Docker unter Linux läuft (mit anderen Worten, es verwendet Linux-Befehle), können wir Docker nicht nativ unter Windows ausführen. Da ich Windows benutze, muss ich für dieses Beispiel eine virtuelle Maschine erstellen, auf der Linux läuft.

Ich werde für diesen Zweck Vagrant verwenden. Vagrant ist ein Tool, mit dem ich eine VirtualBox-Instanz erstellen und starten kann, auf der Linux mit Docker und allen anderen installierten Dingen läuft.

Installation von Vagrant

Um diesen Blog ‚kurz zu halten‘, werde ich für die Installationsanweisungen zu vagrant auf diesen Blog verweisen.

Wenn du eine Umgebung für vagrant installiert hast, gehe zur Befehlszeile deines Systems und erstelle ein Verzeichnis für die Dateien von vagrant. Ich habe Folgendes getan

md vagrant
cd vagrant
md docker
cd docker
From the directory I’ve initialized vagrant using
vagrant init
Blog-6-6

Dadurch wird eine Vagrantdatei erstellt, die die VM beschreibt, die wir verwenden werden. Wenn du die Standardeinstellungen änderst (ich zeige nur die Änderungen an), wird eine geeignete VM erstellt. Ich nehme an, dass du gemäß dem Blog installiert hast, auf den zuvor verwiesen wurde.

Du musst die folgenden Parameter ändern:

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

Sobald du die Änderungen an der Vagrantdatei vorgenommen hast, führe den folgenden Befehl aus:          

vagrant up

Dadurch wird eine Arbeitsumgebung geschaffen, die wir zur Installation von Docker verwenden können. Alle Befehle, die du eingeben wirst, befinden sich auch in einer Vagrantfile, die den gesamten Prozess automatisieren wird. Folge am besten den Anweisungen des Blogs, um ein besseres Verständnis von Docker zu erhalten. Anschließend kannst du die Vagrantfile verwenden und anpassen. Wir werden diese Vagabunddatei in diesen Blog einfügen. Du kannst sie hier herunterladen.

Vagrant SSH

Um Docker zu installieren, installieren wir SSH auf dem neu erstellten Rechner mit dem Befehl

vagrant ssh

Gib in der Befehlszeile Folgendes ein

sudo yum install -y docker

So wird Docker installiert. Um die Installation zu testen, kannst du

docker -v

wird dir die installierte Version von Docker anzeigen.

Stell sicher, dass der Docker-Daemon mit diesem Befehl läuft:

sudo service docker start
Blog-6-7

Ein weiterer Test ist die tatsächliche Ausführung eines Docker-Images in einem Container.

Gib dazu den folgenden Befehl ein:

sudo docker run hello-world
Blog-6-8

Das zeigt auch, wie Docker funktioniert. Das Bild unten zeigt die Schritte:

  1. Die Befehlszeile weist Docker an, ein bestimmtes Docker-Bild auszuführen.
  2. Der Docker-Dämon ruft das Bild vom Docker-Hub ab.
  3. Der Docker-Dämon wird einen Container mit dem abgerufenen Bild erstellen
  4. Der Docker-Dämon wird die Ausgabe entgegennehmen und auf der Kommandozeile anzeigen.
Blog-6-9

Docker Builder

Aber wir brauchen mehr, um eine Docker-Api-Manager-Bibliothek aufzubauen. Natürlich gibt es Versionen im Docker Hub, aber es ist besser, unser eigenes Bild aufzubauen.

Wenn wir ein verteiltes Deployment durchführen wollen, z.B. WSO2-API-Manager-Komponenten in verschiedenen Containern, müssen wir auch Docker Compose installieren.  Auch wenn wir uns keine vollständige verteilte Bereitstellung vorstellen, sind die WSO2-Dockerdateien, die vorher verfügbar waren, verschwunden. Aber wir werden trotzdem zeigen, wie man Docker-Compose installiert. Die WSO2-Dockerfiles enthalten auch einen Docker-Compose-Dateisatz. Wir werden im nächsten Blog mehr dazu erklären.

Installiere python-pip als Voraussetzung:

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

Dann kannst du Docker Compose installieren:

  • sudo pip install docker-compose

Du musst auch deine Python-Pakete unter CentOS 7 aktualisieren, damit Docker-Composite erfolgreich ausgeführt werden kann:

  • sudo yum upgrade -y python*

Zum Schluss installieren wir unzip und wget

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

und lade die WSO2 API Manager Docker-Datein von github herunter

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

Wir entpacken die heruntergeladene Zip-Datei mit

sudo unzip master -d /opt

Wir haben jetzt die Struktur, um unser Docker-Bild zu schaffen. Wir beziehen uns auf /opt/docker-apim-master als die [Docker-Home] Ort.

Fragst dun dich, was sich innerhalb der Datei befindet?

Was ist in der Docker-Datei?

Wenn wir in der Docker-Datei nachschauen, finden wir mehrere Abschnitte:

  • Einstellungen in Bezug auf den Container, Einstellungen wie Benutzer, Benutzergruppe, JAVA_HOME usw.;
  • Installiere die Container-Dateien, Debian, curl, iproute2, telnet, unzip
  • Erstelle eine Benutzergruppe und einen Benutzer;
  • Kopiere die Dateien im Verzeichnis /files in das Verzeichnis;
  • Installiere erforderlichen Pakete (JDK in das Benutzer-Home-Verzeichnis und Entpacken;
  • Benutzer- und Arbeitsverzeichnis festlegen, Umgebungen festlegen und nicht benötigte Dateien entfernen, Posrts freigeben und WSO2 starten

Kurz gesagt, wir schaffen eine typische Umgebung für die Ausführung von WSO2, in diesem Fall in Docker. Nichts weiter.

# ------------------------------------------------------------------------
#
# Urheberrecht 2017 WSO2, Inc. (http://wso2.com)
#
# Lizenziert unter der Apache-Lizenz, Version 2.0 (the "License");
# Du darfst diese Datei nur in Übereinstimmung mit der Lizenz verwenden.
# Du kannst eine Kopie der Lizenz erhalten unter
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Soweit nicht durch geltendes Recht vorgeschrieben oder schriftlich vereinbart, ist Software
# unter der Lizenz verteilt wird, wird auf einer "AS IS" BASIS verteilt,
# OHNE GEWÄHRLEISTUNGEN ODER BEDINGUNGEN JEGLICHER ART, weder ausdrücklich noch stillschweigend.
# Siehe die Lizenz für die spezifische Sprache, die die Genehmigungen und
# Einschränkungen unter der Lizenz
#
# ------------------------------------------------------------------------
# auf das neueste Ubuntu-LTS eingestellt
VON ubuntu:16.04
MAINTAINER WSO2 Docker Maintainers dev@wso2.org
# Benutzerkonfigurationen festlegen
ARG USER=wso2carbon
ARG USER_GROUP=wso2
ARG USER_HOME=/home/${USER}
# abhängiges Dateiverzeichnis einstellen
ARG FILES=./files
# jdk-Konfigurationen einstellen
ARG JDK_ARCHIVE=jdk-8u*-linux-x64.tar.gz
ARG JAVA_HOME=${USER_HOME}/java
# wso2 produktkonfigurationen einstellen
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}

# erforderliche Pakete installieren
AUSFÜHREN 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/*

# eine Benutzergruppe und einen Benutzer erstellen
AUSFÜHREN groupadd --system ${USER_GROUP} && 
	useradd --system --create-home --home-dir ${USER_HOME} --no-log-init -g ${USER_GROUP} ${USER}
# Die Zip-Dateien der jdk- und wso2-Produktverteilung in das Home-Verzeichnis des Benutzers kopieren
KOPIEREN ${FILES}/${JDK_ARCHIVE} ${FILES}/${WSO2_SERVER_PACK} ${USER_HOME}/

#  Installieren des jdk- und wso2-Servers, Entfernen von Distributionen und Festlegen von Ordnerberechtigungen
AUSFÜHREN 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}
# Benutzer und das Arbeitsverzeichnis einstellen
USER ${USER}
WORKDIR ${USER_HOME}
# Umgebungsvariablen setzen
ENV JAVA_HOME=${JAVA_HOME} 
	PATH=$JAVA_HOME/bin:$PATH 
	WSO2_SERVER_HOME=${WSO2_SERVER_HOME}

# Ports freilegen
FREILEGEN 8280 8243 9763 9443 9099 5672 9711 9611 7711 7611 10397

ENTRYPOINT ${WSO2_SERVER_HOME}/bin/wso2server.sh

Um dies zu ermöglichen, müssen wir die Dateien in das Verzeichnis files in der Verzeichnisstruktur kopieren. In diesem Fall das apim-Unterverzeichnis, da es auch eine apim-Anlytik gibt.

Das ist die Struktur.             

├── 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

Damit all dies funktioniert, müssen wir die JDK- und WSO2-APIM zur vagrant Umgebung hinzufügen, damit sie anschließend in das Docker-Bild verschoben werden kann.

Java 8 JDK hinzufügen

Wir müssen Oracle Java JDK 8 herunterladen und dem Dateiverzeichnis hinzufügen.  Nutze das Java SE Development Kit 8u161, da frühere Versionen (151) Probleme mit dem WSO2 hatten.

Du kannst die Datei hier herunterladen.

Nachdem du die Datei heruntergeladen hast, kopiere sie in das Verzeichnis[Docker-Home]/dockerfiles/apim/files

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

WSO2 API Manager Hinzufügen

Lade die WSO2 API Manager 2.1.0-Distribution herunter (http://wso2.com/api-management/try-it/) und kopiere es zu [Docker-Home]/dockerfiles/apim/files .

Erstellen des Docker-Bild

Navigiere zum [Docker-Home]/dockerfiles/apim Verzeichnis.

Führe den Befehl zum Erstellen des docker build wie unten gezeigt aus.

docker build -t wso2am:2.1.0 .

Ausführen des Docker-Images

Wenn du das Bild erstellt hast, kann das Bild wie folgt ausgeführt werden.

docker run -it -p 9443:9443 wso2am:2.1.0
Blog-6-10

Zugriff auf die Verwaltungskonsole

Wie du an der Konsolenausgabe sehen kannst, wird das Bild im Docker-Container ausgeführt. Um auf die Management-UI zugreifen zu können, müssen wir auf die Management-Konsole zugreifen. Da wir ein privates Netzwerk erstellt haben, können wir einen Browser von außerhalb der VirtualBox-Umgebung verwenden, um auf die Management-UI zuzugreifen. 

Um auf die Verwaltungskonsole zuzugreifen, verwende die Docker-Host-IP und Port 9443.

https://192.168.33.77:9443/carbon

Blog-6-11

Fortgeschrittener Docker

Was wir jetzt getan haben, ist ein unkomplizierter Docker-API-Manager, der in VirtualBox ausgeführt wird. Der nächste Blog befasst sich mit Docker Compose, um mehrere Container zu starten und Änderungen an unserem Docker-Container vorzunehmen.

Wenn du Fragen zu diesem Blog hast, kontaktiere uns über den Kommentarbereich dieses Blogs. Schau dir auch unsere WSO2-Tutorials, Webinare oder Whitepapers für weitere technische Informationen an. Benötigst du Unterstützung? Wir bieten WSO2-Produktsupport, WSO2-Entwicklungsunterstützung, WSO2-Betriebsunterstützung und WSO2-Trainingsprogramme.