Für LINUX-PlattformenFür Windows-Plattformen

Docker-Container mit REST-Implementierungs-APIs implementieren

Mit den REST-APIs von DeployService können Sie Liberty- und Node.js-Server als Member eines Verbunds in Docker-Containern implementieren.

Vorbereitende Schritte

Legen Sie die Zielhosts fest, auf denen Sie ein Docker-Image installieren möchten. Installieren Sie Docker auf den Zielhosts. Jeder Zielhost benötigt RXA oder SSH. Weitere Informationen hierzu finden Sie unter RXA für Operationen des Liberty-Verbunds einrichten.

Wenn Sie Node.js in einem Docker-Container verwenden, laden Sie Node.js Version 4.x aus der Docker-Hub-Registry herunter.

Multimedia Hinweis: Das Video Managing an On-Premise, Polyglot Environment with WebSphere Liberty Collectives in einem WASdev-Artikel ergänzt die in diesem Abschnitt beschriebene Prozedur.

Vorgehensweise

  1. Erstellen Sie ein Docker-Image.
    1. Verwenden Sie eine Docker-Datei, um ein Liberty-Image zu erstellen.

      Sie können die folgenden für Docker-Dateibeispiele für Ihre Umgebung ändern. Jedes Beispiel enthält ein joinMember-Script, das die Member-Server im Docker-Container zu einem Verbundcontroller verknüpft, sowie ein removeMember-Script, da den Member-Server im Docker-Container aus dem Verbund entfernt.

    2. Wenn Sie eine Docker-Datei für ein Liberty Network Deployment-Image verwenden, konfigurieren Sie die Datei server.xml für die Verwendung mit der Docker-Datei, z. B.:
      <server description="Default Server">
         <featureManager>
            <feature>webProfile-6.0</feature>
         </featureManager> 
      
         <httpEndpoint id="defaultHttpEndpoint"
                       httpPort="${memberHttpPort}"
                       httpsPort="${memberHttpsPort}" />
      
      </server>
    3. Stellen Sie sicher, dass die Verbundcontrollerdatei server.xml Anweisungen enthält, die den Benutzernamen und das Kennwort für den Controller sowie Implementierungsvariablen definiert.
      • Beispieldatei server.xml für ein Liberty Network Deployment-Image:
           <collectiveController user="admin" password="adminpwd" />
        ... 
           <deployVariable name="memberHttpPort" value="9090" increment="1"/> 
           <deployVariable name="memberHttpsPort" value="9453" increment="1"/>
      • [16.0.0.3 und höher]Beispieldatei server.xml für ein Node.js-Member-Image:
           <collectiveController user="admin" password="adminpwd" />
        ... 
           <deployVariable name="wlpn.appPort" value="9090" increment="1"/> 
           <deployVariable name="wlpn.adminPort" value="9453" increment="1"/>

      Die Implementierungsvariablen müssen Werte setzen, die es jedem Member ermöglichen, eine eindeutige Portnummer auf den Zielhosts zu haben. Weitere Informationen finden Sie unter DeployVariable (deployVariable).

    4. Führen Sie den Docker-Befehl "build" aus, um das Image zu erstellen.
      1. Kopieren Sie die Docker-Datei, die Scripts joinMember und removeMember auf einen Computer, auf dem Docker installiert ist. Wenn Sie eine Docker-Datei für ein Liberty Network Deployment-Image verwenden, kopieren Sie auch die in der Docker-Datei genannte Datei server.xml auf den Computer. Speichern Sie die Dateien in demselben Verzeichnis.
      2. Öffnen Sie ein Befehlsfenster in dem Verzeichnis, in dem die Dateien enthalten sind.
      3. Führen Sie den Docker-Befehl zum Erstellen des Image aus:
        docker build -t Imagename .
      4. Überprüfen Sie die Imageerstellung. Der folgende Befehl gibt den Imagenamen zurück, wenn die Erstellung erfolgreich war.
        docker images
    5. Optional: Übertragen Sie das Docker-Image in eine Docker-Registry mit dem Befehl docker push. Weitere Informationen finden Sie unter Docker-Registry.
  2. Registrieren Sie den Docker-Zielhost beim Verbundcontroller.
    Durch das Registrieren eines Hosts kann der Verbundcontroller das Docker-Image aus der Registry auf diesen Host extrahieren und auf Dateien, Befehle und andere Ressourcen auf dem Host zugreifen. Führen Sie den Befehl registerHost auf der Controllermaschine aus, um den Zielhost zu registrieren. Sehen Sie sich hierzu das folgende Beispiel an:
    wlp/bin/collective registerHost targetHost --host=controllerHost --port=controllerHTTPSPort --user=controllerAdmin --password=controllerAdminPassword --rpcUser=osUser --rpcUserPassword=osUserPassword  --autoAcceptCertificates

    Suchen Sie in der Datei server.xml des Controllers nach den Werten für die Parameter --host, --port, --user und --password. Definieren Sie mit den Parametern --rpcUser und --rpcUserPassword einen Benutzer und ein Kennwort für die Betriebssystemanmeldung, damit keine SSH-Datei mit privatem Schlüssel wie für Zielhosts mit Linux- oder Windows-Betriebssystemen verwendet werden muss. Der mit --rpcUser angegebene Benutzer muss die Betriebssystemberechtigungen für die Position des Implementierungsziels besitzen.

    Wenn bereits ein Host registriert ist, können Sie den Befehl updateHost verwenden, um die Registrierungsinformationen neu zu definieren. Weitere Informationen finden Sie im Artikel Host-Computer werden bei einem Liberty-Verbund registriert.

  3. Wenn das zu implementierende Docker-Image in einer Registry und nicht lokal auf dem Docker-Host, auf dem Sie die Implementierung durchführen, gespeichert ist, können Sie den Verbundcontroller für den Zugriff auf die Registry konfigurieren. Weitere Informationen hierzu finden Sie unter Docker-Registry für einen Verbundcontroller konfigurieren.
  4. Sehen Sie sich die verfügbaren Implementierungsregeln an.
    1. Rufen Sie eine REST-API auf, die die verfügbaren Implementierungsregeln zurückgibt. Verwenden Sie ein Tool, das REST-APIs aufrufen kann, um die verfügbaren Implementierungsregeln abzurufen.
      GET https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/rule

      Der Aufruf gibt die Implementierungsregeln in einer JSON-Struktur zurück, z. B.:

      [16.0.0.3 und höher]
      {"rules":
      [
       {"id":"Liberty Docker Rule","description":"Deploy rule for Liberty Docker containers.","type":"docker","deployCommands":"repository=${dockerRepository};
       registry=${dockerRegistry}; if [ ! $registry ]; then if [ ! $repository];
       then echo 'The dockerRegistry and dockerRepository are not configured in the collective controller, the Docker image to be deployed is assumed available on the target host' ;
       docker run -d -e LICENSE=accept -e CONTAINER_NAME=${containerName} -e CONTAINER_HOST=${wlp.deploy.host} --net=host --name=${containerName} ${imageName} ;
       else echo 'No dockerRegistry configured in the collective controller, Docker image deployments are disabled'; failure='true' ; fi;
       else user=${dockerUser}; password=${dockerUserPassword}; email=${dockerUserEmail};
       if [ ! $repository]; then echo 'No dockerRepository configured in the collective controller, Docker image deployments are disabled'; failure='true' ; fi;
       if [ ! $user]; then echo 'No dockerUser configured in the collective controller, Docker image deployments are disabled'; failure='true' ; fi;
       if [ ! $password]; then echo 'No dockerUserPassword configured in the collective controller, Docker image deployments are disabled'; failure='true'; fi;
       if [ ! $email]; then echo 'No dockerUserEmail configured in the collective controller, Docker image deployments are disabled'; failure='true'; fi;
       if [ ! $failure]; then echo 'Login to the Docker registry at ' $registry ' for repository named ${dockerRepository} as user ' $user ' and pull the image ${imageName} to be started' ;
       docker logout;
       docker login --username=$user --password=$password --email=$email $registry ; docker pull ${dockerRepository}:${imageName} ;
       docker run -d -e LICENSE=accept -e CONTAINER_NAME=${containerName} -e CONTAINER_HOST=${wlp.deploy.host} --net=host --name=${containerName} ${dockerRepository}:${imageName} ; fi; fi;
       if [ ! $failure]; then echo 'Configure the running container ${containerName}' ;
       docker exec -t ${containerName} bash /opt/ibm/docker/joinMember ${containerName} --clusterName=${clusterName}
         --dockerHost=${wlp.deploy.host} --host=${wlp.admin.host} --port=${wlp.admin.port}
         --user=${wlp.admin.user} --password=${wlp.admin.password} --keystorePassword=${keystorePassword};
       else false; fi","undeployCommands":"docker start ${containerName}; 
       docker exec -t ${containerName} bash /opt/ibm/docker/removeMember ${containerName}
         --host=${wlp.admin.host} --port=${wlp.admin.port} --user=${wlp.admin.user} --password=${wlp.admin.password}
         --dockerHost=${wlp.deploy.host} && ( docker stop ${containerName};
       docker rm
        ${containerName} )","startCommands":"docker start
        ${containerName}","stopCommands":"docker stop 
        ${containerName}","restartCommands":"","inputVariables":[
         {"name":"keystorePassword","type":"password","description":"Password for keystores of the deployed server","displayName":"Keystore Password"},
         {"name":"clusterName","type":"String","description":"Name of Liberty Docker container cluster.","defaultValue":"${imageName}_cluster","displayName":"Cluster Name"},
         {"name":"containerName","type":"String","description":"Name of Liberty Docker container.","defaultValue":"${imageName}_container","displayName":"Container Name"},
         {"name":"imageName","type":"dockerImage","description":"Name of Liberty Docker image.","displayName":"Image Name"}],
        "name":"Docker Container","default":true,"runtimeTypes":[{"displayName":"Node.js"},{"displayName":"Liberty"}],"packageType":"Docker Container"
       }
      ]}
    2. Erstellen Sie bei Bedarf eigene Implementierungsregeln, indem Sie DeployRules zu Ihrer Controllerkonfiguration hinzufügen. Weitere Informationen finden Sie unter Deploy Rule (deployRule).
  5. Implementieren Sie das Docker-Image.
    Verwenden Sie ein Tool, das REST-APIs aufrufen kann, um das Docker-Image zu implementieren. Die Implementierungsregel enthält Variablen, die Sie verwenden können, um Eingabewerte für den Aufruf anzugeben, wie z. B. das zu verwendende Docker-Image und den Namen des zu erstellenden Containers. Der Hauptteil der Rückgabe enthält ein Token, das Sie zum Anfordern von Status und Ergebnissen verwenden können.
    Anmerkung: Verwenden Sie für Liberty-Docker-Images und Node.js-Docker-Images dieselbe Liberty-Docker-Regel.
    POST https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/deploy
    
    {
       "rule": "Liberty Docker Rule", 
       "hosts": [ "myHostName" ],
       "variables": [
          { "name":"imageName", "value":"myImageName" },
          { "name":"containerName", "value":"myContainerName" },
          { "name":"clusterName", "value":"myClusterName" },
          { "name":"keystorePassword", "value":"thePassword" }
       ]
    }

    Das Rückgabetoken könnte beispielsweise {"id":3} sein und Sie könnten dieses Token zum Abrufen des Status und der Ergebnisse verwenden.

Nächste Schritte

Fordern Sie den Implementierungsstatus und die Ergebnisse an und überprüfen Sie sie.

  • Rufen Sie eine Liste der Token für angeforderte Implementierungsoperationen ab.
    GET https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/deploy
  • Rufen Sie den Kurzstatus der Implementierungsoperationen ab. Verwenden Sie das Token aus Schritt 4 für {token}. Verwenden Sie also für das Rückgabetoken {"id":3} aus Schritt 3 für {token}.
    GET https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/{token}/status 
    Während der Implementierung gibt die API IN_PROGRESS zurück:
    {"status":{"Zielhost":"IN_PROGRESS"}}
    Nach der Implementierung gibt die API FINISHED zurück:
    {"status":{"Zielhost":"FINISHED"}}
  • Rufen Sie die vollständigen Ergebnisse einer Implementierungsoperation ab. Verwenden Sie das Token aus Schritt 4 für {token}. Verwenden Sie also für das Rückgabetoken {"id":3} aus Schritt 3 für {token}.
    GET https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/{token}/results 
    Nach Abschluss der Implementierung enthalten die Ergebnisse Informationen zur Operation. Das folgende Beispiel zeigt die Ergebnisse für FINISHED:
    {"results":[{"Hostname":"Zielhost","status":"FINISHED","result":0}]}
Deimplementieren Sie einen Docker-Container. Sie müssen keine Implementierungsregel angeben. Die für die Implementierung verwendete Regel wurde zur Implementierungszeit gespeichert. Sie können die Regel für die Deimplementierung verwenden. Die Variable userDir muss den Wert Docker haben.
  • Deimplementieren Sie einen Container.
    POST https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/undeploy
    {     
       "host": "myHostName",
       "userDir":"Docker",     
       "serverName":"myContainerName"
    }
  • Rufen Sie eine Liste der Token für Deimplementierungsoperationen ab.
    GET https://Controller-Host:Controller-Port/ibm/api/collective/v1/deployment/undeploy
    Zum Abrufen des Status und der Ergebnisse führen Sie ähnliche Schritte wie für Implementierungen ab.

Symbol das den Typ des Artikels anzeigt. Taskartikel

Dateiname: twlp_deployservice_docker.html