Als DevOps-Administrator oder -Entwickler können Sie mit Code Stream und VMware Cloud PKS die Bereitstellung Ihrer Softwareanwendungen in einem Kubernetes-Cluster automatisieren. In diesem Anwendungsfall werden weitere Methoden erläutert, mit denen Sie die Freigabe Ihrer Anwendung automatisieren können.

In diesem Anwendungsfall erstellen Sie eine Pipeline, die zwei Phasen umfasst und Jenkins zum Erstellen und Bereitstellen Ihrer Anwendung verwendet.

  • Die erste Phase ist die Entwicklungsphase. Sie verwendet Jenkins, um den Code aus einem Branch im GitHub-Repository zu extrahieren und dann zu erstellen, zu testen und zu veröffentlichen.
  • Die zweite Phase ist die Bereitstellungsphase. Während dieser Phase wird eine Benutzervorgangsaufgabe durchgeführt, die von Key-Usern genehmigt werden muss. Erst dann kann die Pipeline Ihre Anwendung auf dem Kubernetes-Cluster bereitstellen.
Überblick über den Workflow zum Bereitstellen einer Anwendung in einem Kubernetes-Cluster

Die Entwicklungstools, Bereitstellungsinstanzen und die YAML-Datei der Pipeline müssen verfügbar sein, damit die Anwendung von der Pipeline erstellt, getestet, veröffentlicht und bereitgestellt werden kann. Die Pipeline stellt die Anwendung auf Entwicklungs- und Produktionsinstanzen der Kubernetes-Cluster auf AWS bereit.

Workflow zum Freigeben einer Anwendung in einem Kubernetes-Cluster.

Weitere Methoden zum Automatisieren der Freigabe Ihrer Anwendung:

  • Statt Jenkins können Sie zum Erstellen Ihrer Anwendung die native Erstellungsfunktion von Code Stream oder einen Docker-Erstellungshost verwenden.
  • Statt Ihre Anwendung in einem Kubernetes-Cluster bereitzustellen, können Sie sie in einem Amazon Web Services-Cluster (AWS) bereitstellen.

Weitere Informationen zur Verwendung der nativen Erstellungsfunktion von Code Stream und eines Docker-Hosts finden Sie unter:

Voraussetzungen

  • Stellen Sie sicher, dass sich der bereitzustellende Anwendungscode in einem funktionierenden GitHub-Repository befindet.
  • Stellen Sie sicher, dass Sie über eine funktionierende Jenkins-Instanz verfügen.
  • Stellen Sie sicher, dass Sie über einen funktionierenden E-Mail-Server verfügen.
  • Erstellen Sie in Code Stream einen E-Mail-Endpoint, der eine Verbindung mit Ihrem E-Mail-Server herstellt.
  • Richten Sie zwei Kubernetes-Cluster für Entwicklung und Produktion auf Amazon Web Services (AWS) ein, auf denen die Pipeline Ihre Anwendung bereitstellt.
  • Stellen Sie sicher, dass das GitHub-Repository den YAML-Code für die Pipeline und alternativ eine YAML-Datei enthält, in der die Metadaten und Spezifikationen für Ihre Umgebung definiert werden.

Prozedur

  1. Klicken Sie in Code Stream auf Endpoints > Neuer Endpoint und erstellen Sie einen Jenkins-Endpoint, den Sie in der Pipeline zum Extrahieren von Code aus dem GitHub-Repository verwenden.
    Jenkins-Endpoint, der zum Erstellen, Testen und Veröffentlichen Ihrer Anwendung in einem Kubernetes-Cluster verwendet wird.
  2. Klicken Sie zum Erstellen von Kubernetes-Endpoints auf Neuer Endpoint.
    1. Erstellen Sie einen Endpoint für den Kubernetes-Entwicklungscluster.
    2. Erstellen Sie einen Endpoint für den Kubernetes-Produktionscluster.
    Kubernetes-Endpoint, der zum Bereitstellen der Anwendung in einem Kubernetes-Cluster verwendet wird.
  3. Erstellen Sie eine Pipeline, die einen Container Ihrer Anwendung, wie z. B. WordPress, im Kubernetes-Entwicklungscluster bereitstellt, und legen Sie die Eingabeeigenschaften für die Pipeline fest.
    1. Damit die Pipeline einen Code-Commit in GitHub erkennt, der die Pipeline auslöst, klicken Sie in der Pipeline auf die Registerkarte Eingabe und wählen Sie AutoEinfügen-Eigenschaften aus.
    2. Fügen Sie die Eigenschaft mit dem Namen GIT_COMMIT_ID hinzu und klicken Sie auf den Stern.
      Bei Ausführung der Pipeline wird die Commit-ID angezeigt, die vom Git-Auslöser zurückgegeben wird.
    Kubernetes-Pipeline mit festgelegten Git-Eingabeeigenschaften.
  4. Fügen Sie Benachrichtigungen hinzu, um bei erfolgreicher oder fehlgeschlagener Ausführung der Pipeline eine E-Mail zu senden.
    1. Klicken Sie in der Pipeline auf die Registerkarte Benachrichtigungen und dann auf Hinzufügen.
    2. Um nach Abschluss der Pipeline-Ausführung eine E-Mail-Benachrichtigung hinzuzufügen, wählen Sie E-Mail und dann Abschluss aus. Wählen Sie anschließend den E-Mail-Server aus, geben Sie die E-Mail-Adressen ein und klicken Sie auf Speichern.
    3. Zum Hinzufügen einer weiteren E-Mail-Benachrichtigung bei einem Pipeline-Fehler wählen Sie Fehler aus und klicken Sie auf Speichern.
    E-Mail-Benachrichtigungen für Pipelines und Auswahl eines E-Mail-Servers.
  5. Fügen Sie Ihrer Pipeline eine Entwicklungsphase und Aufgaben zum Erstellen, Testen und Veröffentlichen der Anwendung hinzu. Überprüfen Sie anschließend jede Aufgabe.
    1. Fügen Sie zum Erstellen der Anwendung eine Jenkins-Aufgabe hinzu, die den Jenkins-Endpoint verwendet und einen Erstellungsauftrag über den Jenkins-Server ausführt. Damit die Pipeline den Code abrufen kann, geben Sie den Git-Branch in folgendem Format ein: $ {Input. GIT_BRANCH_NAME}
    2. Fügen Sie zum Testen der Anwendung eine Jenkins-Aufgabe hinzu, die denselben Jenkins-Endpoint verwendet und einen Testauftrag über den Jenkins-Server ausführt. Geben Sie anschließend denselben Git-Branch ein.
    3. Fügen Sie zum Veröffentlichen der Anwendung eine Jenkins-Aufgabe hinzu, die denselben Jenkins-Endpoint verwendet und einen Veröffentlichungsauftrag über den Jenkins-Server ausführt. Geben Sie anschließend denselben Git-Branch ein.
    Kubernetes-Pipeline mit Details für die Aufgabe zum Erstellen einer Anwendung.
  6. Fügen Sie der Pipeline eine Bereitstellungsphase und eine Aufgabe hinzu, die eine Genehmigung für die Bereitstellung Ihrer Anwendung erfordert, sowie eine weitere Aufgabe, die die Anwendung in Ihrem Kubernetes-Cluster bereitstellt. Überprüfen Sie anschließend jede Aufgabe.
    1. Fügen Sie zum Anfordern einer Genehmigung für die Bereitstellung Ihrer Anwendung eine Benutzervorgangsaufgabe sowie E-Mail-Adressen für den Benutzer hinzu, der die Bereitstellung genehmigen muss, und geben Sie eine Nachricht ein. Aktivieren Sie anschließend E-Mail senden.
    2. Fügen Sie zum Bereitstellen der Anwendung eine Kubernetes-Aufgabe hinzu. Wählen Sie in den Eigenschaften der Kubernetes-Aufgabe den Kubernetes-Entwicklungscluster, dann die Aktion Erstellen und anschließend die Nutzlastquelle Lokale Definition aus. Wählen Sie dann Ihre lokale YAML-Datei aus.
  7. Fügen Sie einen Git-Webhook hinzu, der Code Stream die Verwendung des Git-Auslösers ermöglicht. Mit diesem Auslöser wird die Pipeline ausgelöst, wenn Entwickler Ihren Code übergeben.
    Git-Webhook, der zum Auslösen der Kubernetes-Pipeline verwendet wird.
  8. Navigieren Sie zum Testen der Pipeline zum GitHub-Repository, aktualisieren Sie die YAML-Datei der Anwendung und übernehmen Sie die Änderung.
    1. Stellen Sie in Code Stream sicher, dass der Commit angezeigt wird.
    1. Klicken Sie auf Auslöser > Git > Aktivität.
    2. Suchen Sie nach dem Auslöser Ihrer Pipeline.
    3. Klicken Sie auf Dashboards > Pipeline-Dashboards.
    4. Suchen Sie im Pipeline-Dashboard im Bereich mit den letzten erfolgreichen Änderungen nach der GIT_COMMIT_ID.
  9. Überprüfen Sie den Pipeline-Code und stellen Sie sicher, dass die Änderung angezeigt wird.

Ergebnisse

Herzlichen Glückwunsch! Sie haben die Bereitstellung Ihrer Softwareanwendung in Ihrem Kubernetes-Cluster automatisiert.

Beispiel: Beispiel für eine Pipeline-YAML, die eine Anwendung in einem Kubernetes-Cluster bereitstellt

Für den in diesem Beispiel verwendeten Pipeline-Typ ähnelt die YAML dem folgenden Code:

apiVersion: v1
kind: Namespace
metadata:
  name: ${input.GIT_BRANCH_NAME}
  namespace: ${input.GIT_BRANCH_NAME}
---  
apiVersion: v1
data:
  .dockercfg: eyJzeW1waG9ueS10YW5nby1iZXRhMi5qZnJvZy5pbyI6eyJ1c2VybmFtZSI6InRhbmdvLWJldGEyIiwicGFzc3dvcmQiOiJhRGstcmVOLW1UQi1IejciLCJlbWFpbCI6InRhbmdvLWJldGEyQHZtd2FyZS5jb20iLCJhdXRoIjoiZEdGdVoyOHRZbVYwWVRJNllVUnJMWEpsVGkxdFZFSXRTSG8zIn19
kind: Secret
metadata:
  name: jfrog
  namespace: ${input.GIT_BRANCH_NAME}
type: kubernetes.io/dockercfg
---   
apiVersion: v1
kind: Service
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  ports:
    - port: 80
  selector:
    app: codestream
    tier: frontend
  type: LoadBalancer 
---
apiVersion: extensions/v1
kind: Deployment
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  selector:
    matchLabels:
      app: codestream
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: codestream
        tier: frontend
    spec:
      containers:
      - name: codestream
        image: cas.jfrog.io/codestream:${input.GIT_BRANCH_NAME}-${Dev.PublishApp.output.jobId}
        ports:
        - containerPort: 80
          name: codestream
      imagePullSecrets:
      - name: jfrog
      

Nächste Maßnahme

Zur Bereitstellung Ihrer Softwareanwendung im Kubernetes-Produktionscluster führen Sie die Schritte erneut aus und wählen Sie den Produktionscluster aus.

Weitere Informationen zur Integration von Code Stream mit Jenkins finden Sie unter Vorgehensweise zum Integrieren von Code Stream in Jenkins.