TOC

Webinar-Reihe: GitOps-Toolsets auf Kubernetes mit CircleCI- und Argo-CD

Einführung

Die Verwendung von Kubernetes zur Bereitstellung Ihrer Anwendung bietet erhebliche infrastrukturelle Vorteile, z. B. flexible Skalierung, Verwaltung verteilter Komponenten und Kontrolle über verschiedene Versionen Ihrer Anwendung. Mit der erweiterten Steuerung steigt jedoch die Komplexität, die es besonders schwierig macht, CI / CD-Systeme für die kooperative Codeentwicklung, Versionskontrolle, Änderungsprotokollierung sowie die automatische Bereitstellung und das automatische Rollback manuell zu verwalten. Um diesen Schwierigkeiten Rechnung zu tragen, haben die Entwickler von DevOps verschiedene Methoden für die Kubernetes CI / CD-Automatisierung entwickelt, darunter das Tooling-System und Best Practices mit dem Namen GitOps. GitOps verwendet, wie von Weaveworks in einem 2017-Blogpost vorgeschlagen, https: //git-scm.com/[Git als "einzige Quelle der Wahrheit" für CI / CD-Prozesse, Integration von Codeänderungen in ein einziges gemeinsames Repository pro Projekt und Verwendung von Pull-Anforderungen zur Verwaltung der Infrastruktur und Bereitstellung.

Es gibt viele Tools, die Git als Schwerpunkt für DevOps-Prozesse auf Kubernetes verwenden, darunter Gitkube, die von Hasura, https: // entwickelt wurden. github.com/weaveworks/flux[Flux] von Weaveworks und Jenkins X, das Thema der https://www.digitalocean.com/community/tutorials / webinar-serie-kubernetes-paketverwaltung-mit-helm-und-ci-cd-mit-jenkins-x [zweites webinar in dieser serie]. In diesem Tutorial werden zwei zusätzliche Tools vorgestellt, mit denen Sie Ihr eigenes cloudbasiertes GitOps CI / CD-System einrichten können: Das Continuous Integration-Tool CircleCI und https: //argoproj.github.io/argo-cd[Argo CD], ein deklaratives Continuous Delivery-Tool.

CircleCI verwendet die Repositorys GitHub oder Bitbucket, um die Anwendungsentwicklung zu organisieren und das Erstellen und Testen auf Kubernetes zu automatisieren. Durch die Integration in das Git-Repository können CircleCI-Projekte erkennen, wann eine Änderung am Anwendungscode vorgenommen wurde, und diesen automatisch testen. Benachrichtigungen über die Änderung und die Testergebnisse werden per E-Mail oder über andere Kommunikationstools wie https://slack.com/ gesendet. [Locker]. CircleCI protokolliert all diese Änderungen und Testergebnisse und die browserbasierte Benutzeroberfläche ermöglicht es Benutzern, die Tests in Echtzeit zu überwachen, sodass ein Team immer über den Status seines Projekts informiert ist.

Als Unterprojekt der Argo Workflow Management Engine für Kubernetes bietet Argo CD Continuous Delivery-Tools, die Ihre Anwendung automatisch synchronisieren und bereitstellen, sobald Änderungen in Ihrem GitHub-Repository vorgenommen werden. Durch die Verwaltung der Bereitstellung und des Lebenszyklus einer Anwendung werden Lösungen für die Versionskontrolle, Konfigurationen und Anwendungsdefinitionen in Kubernetes-Umgebungen bereitgestellt, die komplexe Daten mit einer leicht verständlichen Benutzeroberfläche organisieren. Es kann verschiedene Arten von Kubernetes-Manifesten verarbeiten, einschließlich ksonnet -Anwendungen, Kustomize -Anwendungen, Helm -Diagrammen und YAML / json-Dateien und unterstützt Webhook-Benachrichtigungen von GitHub, GitLab und Bitbucket.

In diesem letzten Artikel der *CI/CD with Kubernetes * series werden Sie diese GitOps-Tools von ausprobieren :

  • Einrichten von Pipeline-Triggern zur Automatisierung von Anwendungstests mit CircleCI und GitHub.

  • Synchronisieren und Bereitstellen einer Anwendung aus einem GitHub-Repository mit Argo CD.

Am Ende dieses Tutorials erhalten Sie grundlegende Informationen zum Erstellen einer CI / CD-Pipeline auf Kubernetes mit einem GitOps-Tool-Set.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

  • Ein Ubuntu 16.04 Server mit 16 GB RAM oder mehr. Da dieses Tutorial nur zu Demonstrationszwecken gedacht ist, werden Befehle vom Konto * root * ausgeführt. * Beachten Sie, dass die uneingeschränkten Berechtigungen dieses Kontos nicht den bewährten Methoden für die Produktion entsprechen und sich auf Ihr System auswirken können. * Aus diesem Grund wird empfohlen, die folgenden Schritte in einer Testumgebung wie einer virtuellen Maschine oder einem https: / / www.digitalocean.com/products/droplets/[DigitalOcean Droplet].

  • Ein https://hub.docker.com [Docker Hub-Konto]. Eine Übersicht über die ersten Schritte mit Docker Hub finden Sie unter diese Anleitung.

  • Ein https://github.com [GitHub] Konto und Grundkenntnisse von GitHub. Eine Einführung in die Verwendung von GitHub finden Sie unter How To Create a Pull Request auf GitHub Lernprogramm.

  • Vertrautheit mit Kubernetes-Konzepten. Weitere Informationen finden Sie im Artikel Einführung in Kubernetes.

  • Ein Kubernetes-Cluster mit dem Befehlszeilentool kubectl. Dieses Tutorial wurde in einem simulierten Kubernetes-Cluster getestet, das in einer lokalen Umgebung mit Minikube eingerichtet wurde. Mit diesem Programm können Sie Kubernetes-Tools auf Ihrem eigenen Computer ausprobieren, ohne dass dies erforderlich ist Richten Sie einen echten Kubernetes-Cluster ein. Folgen Sie Schritt 1 des zweiten Webinars in dieser Reihe, https://www.digitalocean.com/community/tutorials/webinar-series-kubernetes-package-management-with-helm-and-ci-cd, um einen Minikube-Cluster zu erstellen -with-jenkins-x [Kubernetes Package Management mit Helm und CI / CD mit Jenkins X].

Schritt 1 - Einrichten Ihres CircleCI-Workflows

In diesem Schritt stellen Sie einen Standard-CircleCI-Workflow zusammen, der drei Jobs umfasst: Testen von Code, Erstellen eines Images und Übertragen dieses Images an Docker Hub. In der Testphase verwendet CircleCI pytest, um den Code für eine RSVP-Beispielanwendung zu testen. Anschließend wird das Image des Anwendungscodes erstellt und an DockerHub übertragen.

Geben Sie zunächst CircleCI Zugriff auf Ihr GitHub-Konto. Navigieren Sie dazu in Ihrem bevorzugten Webbrowser zu https://circleci.com/ [+ https: // circleci.com / +]:

image: https://assets.digitalocean.com/articles/cart_64920/CircleCI_Main_Site.png [CircleCI Landing Page]

Oben rechts auf der Seite befindet sich die Schaltfläche * Anmelden *. Klicken Sie auf diese Schaltfläche und dann auf der folgenden Seite auf * Mit GitHub anmelden *. Auf der CircleCI-Website werden Sie zur Eingabe Ihrer GitHub-Anmeldeinformationen aufgefordert:

image: https: //assets.digitalocean.com/articles/cart_64920/CircleCI_GitHub_Sign_In.png [Bei GitHub CircleCI anmelden]

Wenn Sie Ihren Benutzernamen und Ihr Kennwort hier eingeben, erhält CircleCI die Berechtigung, Ihre GitHub-E-Mail-Adresse zu lesen, Schlüssel bereitzustellen und Service-Hooks zu Ihrem Repository hinzuzufügen, eine Liste Ihrer Repositorys zu erstellen und Ihrem GitHub-Konto einen SSH-Schlüssel hinzuzufügen. Diese Berechtigungen sind erforderlich, damit CircleCI Änderungen in Ihrem Git-Repository überwacht und darauf reagiert. Wenn Sie mehr über die angeforderten Berechtigungen erfahren möchten, bevor Sie CircleCI Ihre Kontodaten mitteilen, lesen Sie die CircleCI documentation.

Nachdem Sie diese Berechtigungen überprüft haben, geben Sie Ihre GitHub-Anmeldeinformationen ein und klicken Sie auf "Anmelden". CircleCI wird sich dann in Ihr GitHub-Konto integrieren und Ihren Browser auf die CircleCI-Begrüßungsseite umleiten:

image: https://assets.digitalocean.com/articles/cart_64920/CircleCI_Welcome_Page.png [Willkommensseite für CircleCI]

Nachdem Sie nun Zugriff auf Ihr CircleCI-Dashboard haben, öffnen Sie ein anderes Browserfenster und navigieren Sie zum GitHub-Repository für dieses Webinar: `+https://github.com / do-community / rsvpapp-webinar4 + `. Wenn Sie aufgefordert werden, sich bei GitHub anzumelden, geben Sie Ihren Benutzernamen und Ihr Passwort ein. In diesem Repository finden Sie eine RSVP-Beispielanwendung, die vom CloudYuga -Team erstellt wurde. In diesem Tutorial verwenden Sie diese Anwendung, um einen GitOps-Workflow zu demonstrieren. Fügen Sie dieses Repository Ihrem GitHub-Konto hinzu, indem Sie oben rechts auf dem Bildschirm auf die Schaltfläche * Fork * klicken.

Wenn Sie das Repository gespalten haben, leitet GitHub Sie zu "+ https: // github.com // rsvpapp-webinar4 +" weiter. Auf der linken Seite des Bildschirms sehen Sie die Schaltfläche * Branch: master *. Klicken Sie auf diese Schaltfläche, um die Liste der Zweige für dieses Projekt anzuzeigen. Hier bezieht sich der Zweig * master * auf die aktuelle offizielle Version der Anwendung. Andererseits ist der * dev * -Zweig eine Entwicklungs-Sandbox, in der Sie Änderungen testen können, bevor Sie sie in die offizielle Version des * master * -Zweigs hochstufen. Wählen Sie den Zweig * dev *.

Jetzt, da Sie sich im Entwicklungsabschnitt dieses Demo-Repositorys befinden, können Sie mit dem Einrichten einer Pipeline beginnen. CircleCI benötigt eine YAML-Konfigurationsdatei im Repository, die die Schritte beschreibt, die zum Testen Ihrer Anwendung erforderlich sind. Das von Ihnen gabelte Repository hat diese Datei bereits unter + .circleci / config.yml +; Um das Einrichten von CircleCI zu üben, löschen Sie diese Datei und erstellen Sie Ihre eigene.

Um diese Konfigurationsdatei zu erstellen, klicken Sie auf die Schaltfläche * Neue Datei erstellen * und erstellen Sie eine Datei mit dem Namen + .circleci / config.yml +:

image: https://assets.digitalocean.com/articles/cart_64920/GitHub_Repo_CircleCI_Config.png [GitHub Neue Dateiseite erstellen]

Sobald Sie diese Datei in GitHub geöffnet haben, können Sie den Workflow für CircleCI konfigurieren. Um mehr über den Inhalt dieser Datei zu erfahren, fügen Sie die Abschnitte Stück für Stück hinzu. Fügen Sie zunächst Folgendes hinzu:

circleci/config.yml
version: 2
jobs:
 test:
   machine:
     image: circleci/classic:201808-01
     docker_layer_caching: true
   working_directory: ~/repo

. . .

Im vorhergehenden Code bezieht sich "+ version " auf die Version von CircleCI, die Sie verwenden werden. ` jobs: test: ` bedeutet, dass Sie einen Test für Ihre Anwendung einrichten und ` machine: image: ` gibt an, wo CircleCI den Test durchführen wird, in diesem Fall eine virtuelle Maschine basierend auf dem ` circleci / klassisch: 201808-01 + `image.

Fügen Sie als Nächstes die Schritte hinzu, die CircleCI während des Tests ausführen soll:

circleci/config.yml
. . .
   steps:
     - checkout
     - run:
         name: install dependencies
         command: |
           sudo rm /var/lib/dpkg/lock
           sudo dpkg --configure -a
           sudo apt-get install software-properties-common
           sudo add-apt-repository ppa:fkrull/deadsnakes
           sudo apt-get update
           sleep 5
           sudo rm /var/lib/dpkg/lock
           sudo dpkg --configure -a
           sudo apt-get install python3.5
           sleep 5
           python -m pip install -r requirements.txt

     # run tests!
     # this example uses Django's built-in test-runner
     # other common Python testing frameworks include pytest and nose
     # https://pytest.org
     # https://nose.readthedocs.io

     - run:
         name: run tests
         command: |
           python -m pytest tests/test_rsvpapp.py

. . .

Die Testschritte werden nach den Schritten "" aufgeführt: + ", beginnend mit" + - checkout + ", wodurch der Quellcode Ihres Projekts ausgecheckt und in den Jobspeicher kopiert wird. Als nächstes führt der Schritt " - run: name: install dependencies " die aufgelisteten Befehle aus, um die für den Test erforderlichen Abhängigkeiten zu installieren. In diesem Fall verwenden Sie den in https://www.djangoproject.com/[Django Web Framework] integrierten Test-Runner und das Test-Tool " pytest ". Nachdem CircleCI diese Abhängigkeiten heruntergeladen hat, weist der Schritt ` -run: name: run tests +` CircleCI an, die Tests für Ihre Anwendung auszuführen.

Fügen Sie nach Abschluss des Jobs "+ test " den folgenden Inhalt hinzu, um den Job " build +" zu beschreiben:

circleci/config.yml
. . .
 build:

   machine:
     image: circleci/classic:201808-01
     docker_layer_caching: true
   working_directory: ~/repo

   steps:
     - checkout
     - run:
         name: build image
         command: |
           docker build -t $DOCKERHUB_USERNAME/rsvpapp:$CIRCLE_SHA1 .

 push:
   machine:
     image: circleci/classic:201808-01
     docker_layer_caching: true
   working_directory: ~/repo
   steps:
     - checkout
     - run:
         name: Push image
         command: |
           docker build -t $DOCKERHUB_USERNAME/rsvpapp:$CIRCLE_SHA1 .
           echo $DOCKERHUB_PASSWORD | docker login --username $DOCKERHUB_USERNAME --password-stdin
           docker push $DOCKERHUB_USERNAME/rsvpapp:$CIRCLE_SHA1

. . .

Nach wie vor bedeutet "+ machine: image: ", dass CircleCI die Anwendung in einer virtuellen Maschine basierend auf dem angegebenen Image erstellt. Unter " steps: " finden Sie wieder " - checkout", gefolgt von "+ - run: name: build image". Dies bedeutet, dass CircleCi einen Docker-Container aus dem "+ rsvpapp " - Image in Ihrem Docker Hub-Repository erstellt. Sie setzen die Umgebungsvariable ` $ DOCKERHUB_USERNAME +` in der CircleCI-Schnittstelle, die das Lernprogramm nach Abschluss dieser YAML-Datei behandelt.

Nach Abschluss des Jobs "+ build " wird das resultierende Image mit dem Job " push +" an Ihr Docker Hub-Konto übertragen.

Fügen Sie abschließend die folgenden Zeilen hinzu, um die "+ Workflows +" zu bestimmen, die die zuvor definierten Jobs koordinieren:

circleci/config.yml
. . .
workflows:
 version: 2
 build-deploy:
   jobs:
     - test:
         context: DOCKERHUB
         filters:
           branches:
             only: dev
     - build:
         context: DOCKERHUB
         requires:
           - test
         filters:
           branches:
             only: dev
     - push:
         context: DOCKERHUB
         requires:
           - build
         filters:
           branches:
             only: dev

Diese Zeilen stellen sicher, dass CircleCI die Jobs "+ test", "+ build" und "+ push" in der richtigen Reihenfolge ausführt. + context: DOCKERHUB + bezieht sich auf den Kontext, in dem der Test stattfinden wird. Sie erstellen diesen Kontext nach Abschluss dieser YAML-Datei. Die Zeile + only: dev + verhindert, dass der Workflow nur dann ausgelöst wird, wenn eine Änderung am Zweig * dev * Ihres Repositorys vorliegt, und stellt sicher, dass CircleCI den Code von * dev * erstellt und testet.

Nachdem Sie den gesamten Code für die Datei "+ .circleci / config.yml +" hinzugefügt haben, sollte der Inhalt wie folgt lauten:

circleci/config.yml
version: 2
jobs:
 test:
   machine:
     image: circleci/classic:201808-01
     docker_layer_caching: true
   working_directory: ~/repo

   steps:
     - checkout
     - run:
         name: install dependencies
         command: |
           sudo rm /var/lib/dpkg/lock
           sudo dpkg --configure -a
           sudo apt-get install software-properties-common
           sudo add-apt-repository ppa:fkrull/deadsnakes
           sudo apt-get update
           sleep 5
           sudo rm /var/lib/dpkg/lock
           sudo dpkg --configure -a
           sudo apt-get install python3.5
           sleep 5
           python -m pip install -r requirements.txt

     # run tests!
     # this example uses Django's built-in test-runner
     # other common Python testing frameworks include pytest and nose
     # https://pytest.org
     # https://nose.readthedocs.io

     - run:
         name: run tests
         command: |
           python -m pytest tests/test_rsvpapp.py

 build:

   machine:
     image: circleci/classic:201808-01
     docker_layer_caching: true
   working_directory: ~/repo

   steps:
     - checkout
     - run:
         name: build image
         command: |
           docker build -t $DOCKERHUB_USERNAME/rsvpapp:$CIRCLE_SHA1 .

 push:
   machine:
     image: circleci/classic:201808-01
     docker_layer_caching: true
   working_directory: ~/repo
   steps:
     - checkout
     - run:
         name: Push image
         command: |
           docker build -t $DOCKERHUB_USERNAME/rsvpapp:$CIRCLE_SHA1 .
           echo $DOCKERHUB_PASSWORD | docker login --username $DOCKERHUB_USERNAME --password-stdin
           docker push $DOCKERHUB_USERNAME/rsvpapp:$CIRCLE_SHA1

workflows:
 version: 2
 build-deploy:
   jobs:
     - test:
         context: DOCKERHUB
         filters:
           branches:
             only: dev
     - build:
         context: DOCKERHUB
         requires:
           - test
         filters:
           branches:
             only: dev
     - push:
         context: DOCKERHUB
         requires:
           - build
         filters:
           branches:
             only: dev

Nachdem Sie diese Datei zum * dev * -Zweig Ihres Repositorys hinzugefügt haben, kehren Sie zum CircleCI-Dashboard zurück.

Als Nächstes erstellen Sie einen CircleCI-Kontext, der die Umgebungsvariablen enthält, die für den in der vorherigen YAML-Datei beschriebenen Workflow erforderlich sind. Auf der linken Seite des Bildschirms befindet sich die Schaltfläche * EINSTELLUNGEN *. Klicken Sie darauf und wählen Sie dann * Contexts * unter der Überschrift * ORGANISATION *. Klicken Sie abschließend auf die Schaltfläche * Create Context * (Kontext erstellen) auf der rechten Seite des Bildschirms:

image: https: //assets.digitalocean.com/articles/cart_64920/CircleCI_Create_Context_Screen.png [Kontextbildschirm für CircleCI erstellen]

CircleCI wird Sie dann nach dem Namen dieses Kontexts fragen. Geben Sie "+ DOCKERHUB " ein und klicken Sie dann auf "Erstellen". Nachdem Sie den Kontext erstellt haben, wählen Sie den Kontext * DOCKERHUB * aus und klicken Sie auf die Schaltfläche * Umgebungsvariable hinzufügen *. Geben Sie als erstes den Namen ` DOCKERHUB_USERNAME +` ein und geben Sie als * Wert * Ihren Docker Hub-Benutzernamen ein.

image: https: //assets.digitalocean.com/articles/cart_64920/Git_Hub_Docker_Username.png [Umgebungsvariablenbildschirm für CircleCI hinzufügen]

Fügen Sie dann eine weitere Umgebungsvariable hinzu, nennen Sie sie diesmal "+ DOCKERHUB_PASSWORD +" und geben Sie in das Feld "Wert" Ihr Docker Hub-Kennwort ein.

Wenn Sie die beiden Umgebungsvariablen für Ihren * DOCKERHUB * -Kontext erstellen, erstellen Sie ein CircleCI-Projekt für die Test-RSVP-Anwendung. Wählen Sie dazu die Schaltfläche * ADD PROJECTS * aus dem Menü auf der linken Seite. Daraufhin wird eine Liste der GitHub-Projekte angezeigt, die mit Ihrem Konto verknüpft sind. Wählen Sie * rsvpapp-webinar4 * aus der Liste aus und klicken Sie auf die Schaltfläche * Projekt einrichten *.

Sie befinden sich jetzt auf der Seite * Projekt einrichten *:

image: https: //assets.digitalocean.com/articles/cart_64920/CircleCI_Set_Up_Project_Screen.png [Projektbildschirm für CircleCI einrichten]

Am oberen Bildschirmrand weist CircleCI Sie an, eine "+ config.yml +" - Datei zu erstellen. Da Sie dies bereits getan haben, scrollen Sie nach unten, um die Schaltfläche * Start Building * auf der rechten Seite zu finden. Durch Auswahl dieser Option weisen Sie CircleCI an, Ihre Anwendung auf Änderungen zu überwachen.

Klicken Sie auf die Schaltfläche * Start Building *. CircleCI leitet Sie zu einer Seite mit dem Fortschritt und dem Status der Erstellung weiter, für die noch keine Erstellung vorliegt.

Um den Pipeline-Trigger zu testen, rufen Sie das kürzlich gespaltene Repository unter "+ https: // github.com // rsvpapp-webinar4 " auf und nehmen Sie einige Änderungen nur im Zweig " dev " vor. Da Sie den Verzweigungsfilter ` only: dev ` zu Ihrer ` .circleci / config +` -Datei hinzugefügt haben, wird CI nur dann erstellt, wenn Änderungen in der * dev * -Zweigstelle vorgenommen werden. Wenn Sie den * dev * -Zweigcode ändern, wird CircleCI einen neuen Workflow in der Benutzeroberfläche auslösen. Klicken Sie auf den laufenden Workflow und Sie finden die Details zu den Aktivitäten von CircleCI:

image: https: //assets.digitalocean.com/articles/cart_64920/CircleCI_Running_Workflow.png [CircleCI Project Workflow Page]

Während sich Ihr CircleCI-Workflow um die kontinuierliche Integration Ihres GitOps CI / CD-Systems kümmert, können Sie Argo CD auf Ihrem Kubernetes-Cluster installieren und konfigurieren, um die kontinuierliche Bereitstellung zu gewährleisten.

Schritt 2 - Installieren und Konfigurieren von Argo CD auf Ihrem Kubernetes Cluster

Genau wie CircleCI GitHub verwendet, um automatische Tests auf Änderungen am Quellcode auszulösen, verbindet Argo CD Ihren Kubernetes-Cluster mit Ihrem GitHub-Repository, um auf Änderungen zu achten und die aktualisierte Anwendung automatisch bereitzustellen. Um dies einzurichten, müssen Sie zuerst die Argo-CD in Ihrem Cluster installieren.

Erstellen Sie zunächst einen namespace mit dem Namen + argocd +:

kubectl create namespace argocd

In diesem Namespace führt Argo CD alle Dienste und Ressourcen aus, die zum Erstellen des Workflow für die kontinuierliche Bereitstellung erforderlich sind.

Laden Sie als Nächstes die Argo-CD-Manifest aus dem offiziellen GitHub-Repository für Argo herunter:

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd//manifests/install.yaml

In diesem Befehl weist das Flag "+ -n " " kubectl " an, das Manifest auf den Namespace " argocd " anzuwenden, und " -f +" gibt den Dateinamen für das Manifest an, das angewendet werden soll eine, die aus dem Argo-Repository heruntergeladen wurde.

Mit dem Befehl + kubectl get + finden Sie die Pods, die jetzt im Namespace + argocd + ausgeführt werden:

kubectl get pod -n argocd

Mit diesem Befehl erhalten Sie eine Ausgabe ähnlich der folgenden:

NAME                                      READY     STATUS    RESTARTS   AGE
application-controller-6d68475cd4-j4jtj   1/1       Running   0          1m
argocd-repo-server-78f556f55b-tmkvj       1/1       Running   0          1m
argocd-server-78f47bf789-trrbw            1/1       Running   0          1m
dex-server-74dc6c5ff4-fbr5g               1/1       Running   0          1m

Nachdem Argo CD auf Ihrem Cluster ausgeführt wird, laden Sie das Argo CD CLI-Tool herunter, damit Sie das Programm über Ihre Befehlszeile steuern können:

curl -sSL -o /usr/local/bin/argocd https://github.com/argoproj/argo-cd/releases/download//argocd-linux-amd64

Nachdem Sie die Datei heruntergeladen haben, verwenden Sie "+ chmod +", um sie ausführbar zu machen:

chmod +x /usr/local/bin/argocd

Um den Argo CD-Dienst zu finden, führen Sie den Befehl + kubectl get + im Namespace + argocd + aus:

kubectl get svc -n argocd argocd-server

Sie erhalten eine Ausgabe ähnlich der folgenden:

OutputNAME            TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
argocd-server   ClusterIP   10.109.189.243   <none>        80/TCP,443/TCP   8m

Greifen Sie jetzt auf den Argo CD API-Server zu. Dieser Server verfügt nicht automatisch über eine externe IP-Adresse. Sie müssen daher zuerst die API verfügbar machen, damit Sie von Ihrem Browser auf Ihrer lokalen Workstation darauf zugreifen können. Verwenden Sie dazu "+ kubectl port-forward ", um den Port " 8080 " auf Ihrer lokalen Workstation an den TCP-Port " 80 " des Dienstes " argocd-server +" aus der vorherigen Ausgabe weiterzuleiten:

kubectl port-forward svc/argocd-server -n argocd 8080:80

Die Ausgabe wird sein:

OutputForwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

Sobald Sie den Befehl + port-forward + ausführen, verschwindet Ihre Eingabeaufforderung von Ihrem Terminal. Um weitere Befehle für Ihren Kubernetes-Cluster einzugeben, öffnen Sie ein neues Terminalfenster und melden Sie sich bei Ihrem Remote-Server an.

Verwenden Sie zum Herstellen der Verbindung "+ ssh ", um den " 8080 " - Port von Ihrem lokalen Computer weiterzuleiten. Öffnen Sie zunächst ein zusätzliches Terminalfenster und geben Sie auf Ihrer lokalen Workstation den folgenden Befehl ein, wobei "+" durch die IP-Adresse des Remoteservers ersetzt wird, auf dem Sie Ihren Kubernetes-Cluster ausführen:

ssh -L 8080:localhost:8080 root@

Um sicherzustellen, dass der Argo CD-Server für Ihre lokale Workstation verfügbar ist, öffnen Sie einen Browser und navigieren Sie zu der URL "+ localhost: 8080 +". Sie sehen die Argo CD Landing Page:

image: https: //assets.digitalocean.com/articles/cart_64920/Argo_CD_Sign_In_Page.png [Anmeldeseite für ArgoCD]

Nachdem Sie Argo CD installiert und seinen Server für Ihre lokale Workstation verfügbar gemacht haben, können Sie mit dem nächsten Schritt fortfahren, in dem Sie GitHub mit Ihrem Argo CD-Dienst verbinden.

Schritt 3 - Verbinden der Argo CD mit GitHub

Damit Argo CD GitHub hören und Bereitstellungen mit Ihrem Repository synchronisieren kann, müssen Sie zuerst Argo CD mit GitHub verbinden. Melden Sie sich dazu bei Argo an.

Standardmäßig ist das Kennwort für Ihr Argo CD-Konto der Name des Pods für den Argo CD-API-Server. Wechseln Sie zurück zu dem Terminalfenster, das auf Ihrem Remoteserver angemeldet ist, die Portweiterleitung jedoch nicht verarbeitet. Rufen Sie das Passwort mit dem folgenden Befehl ab:

kubectl get pods -n argocd -l app=argocd-server -o name | cut -d'/' -f 2

Sie erhalten den Namen des Pods, auf dem der Argo API-Server ausgeführt wird:

Outputargocd-server-

Geben Sie den folgenden Befehl ein, um sich über die CLI anzumelden:

argocd login localhost:8080

Sie erhalten folgende Eingabeaufforderung:

OutputWARNING: server certificate had error: x509: certificate signed by unknown authority. Proceed insecurely (y/n)?

Für diese Demonstration geben Sie "+ y " ein, um ohne sichere Verbindung fortzufahren. Argo CD fordert Sie dann auf, Ihren Benutzernamen und Ihr Passwort einzugeben. Geben Sie als Benutzernamen * admin * und als Passwort den vollständigen Pod-Namen ` argocd-server +` ein. Sobald Sie Ihre Anmeldeinformationen eingegeben haben, wird die folgende Nachricht angezeigt:

Output'admin' logged in successfully
Context 'localhost:8080' updated

Nachdem Sie sich angemeldet haben, verwenden Sie den folgenden Befehl, um Ihr Kennwort zu ändern:

argocd account update-password

Argo CD fragt Sie nach Ihrem aktuellen Passwort und dem Passwort, in das Sie es ändern möchten. Wählen Sie ein sicheres Passwort und geben Sie es an den Eingabeaufforderungen ein. Sobald Sie dies getan haben, verwenden Sie Ihr neues Passwort, um sich neu anzumelden:

argocd relogin

Geben Sie Ihr Passwort erneut ein und Sie erhalten:

OutputContext 'localhost:8080' updated

Wenn Sie eine Anwendung auf einem Cluster außerhalb des Argo CD-Clusters bereitstellen, müssen Sie die Anmeldeinformationen des Anwendungsclusters bei Argo CD registrieren. Befinden sich Argo CD und Ihre Anwendung wie in diesem Lernprogramm im selben Cluster, verwenden Sie "+ https: // kubernetes.default.svc +" als Kubernetes-API-Server, wenn Sie Argo CD mit Ihrer Anwendung verbinden.

Um zu demonstrieren, wie man einen externen Cluster registrieren kann, erhalten Sie zunächst eine Liste Ihrer Kubernetes-Kontexte:

kubectl config get-contexts

Du wirst kriegen:

OutputCURRENT   NAME       CLUSTER    AUTHINFO   NAMESPACE
*            minikube   minikube

Geben Sie zum Hinzufügen eines Clusters den folgenden Befehl mit dem Namen Ihres Clusters anstelle des hervorgehobenen Namens ein:

argocd cluster add

In diesem Fall würde der vorhergehende Befehl ergeben:

OutputINFO[0000] ServiceAccount "argocd-manager" created
INFO[0000] ClusterRole "argocd-manager-role" created
INFO[0000] ClusterRoleBinding "argocd-manager-role-binding" created, bound "argocd-manager" to "argocd-manager-role"
Cluster 'minikube' added

Nachdem Sie Ihre Anmeldeinformationen für Argo CD eingerichtet und das Hinzufügen eines externen Clusters getestet haben, wechseln Sie zur Zielseite von Argo CD und melden Sie sich von Ihrer lokalen Workstation aus an. Argo CD leitet Sie zur Anwendungsseite von Argo CD weiter:

image: https://assets.digitalocean.com/articles/cart_64920/Argo_CD_Applications_PAge.png [Argo CD-Anwendungsbildschirm]

Klicken Sie von hier aus auf das Symbol * Einstellungen * in der linken Symbolleiste, klicken Sie auf * Repositorys * und dann auf * REPO VERBINDEN *. Argo CD zeigt Ihnen drei Felder für Ihre GitHub-Informationen an:

image: https://assets.digitalocean.com/articles/cart_64920/Argo_CD_Connect_Git_Repo_Page.png [Argo CD Connect Git Repo-Seite]

Geben Sie in das Feld für die * Repository-URL * "+ https: // github.com // rsvpapp-webinar4 +" ein und geben Sie dann Ihren GitHub-Benutzernamen und Ihr Kennwort ein. Nachdem Sie Ihre Anmeldeinformationen eingegeben haben, klicken Sie oben auf dem Bildschirm auf die Schaltfläche * VERBINDEN *.

Wenn Sie Ihr Repository mit der Demo-RSVP-App mit Argo CD verbunden haben, wählen Sie das Symbol * Apps * in der linken Symbolleiste, klicken Sie auf die Schaltfläche * + * in der oberen rechten Ecke des Bildschirms und wählen Sie * Neue Anwendung *. Wählen Sie auf der Seite "Repository auswählen" Ihr GitHub-Repository für die RSVP-App aus und klicken Sie auf "Weiter". Wählen Sie dann * APP AUS VERZEICHNIS ERSTELLEN *, um zu einer Seite zu gelangen, auf der Sie aufgefordert werden, Ihre Anwendungsparameter zu überprüfen:

image: https: //assets.digitalocean.com/articles/cart_64920/Argo_CD_Review_Application_Page.png [Anwendungsparameter-Seite von Argo CD Review]

Das Feld * Path * gibt an, wo sich die YAML-Datei für Ihre Anwendung in Ihrem GitHub-Repository befindet. Geben Sie für dieses Projekt "+ k8s " ein. Geben Sie für * Anwendungsname * " rsvpapp " ein und wählen Sie für * Cluster-URL * " https: // kubernetes.default.svc " aus dem Dropdown-Menü aus, da sich Argo CD und Ihre Anwendung im selben Kubernetes-Cluster befinden. Geben Sie abschließend " default +" für "Namespace" ein.

Wenn Sie Ihre Anwendungsparameter eingegeben haben, klicken Sie oben auf dem Bildschirm auf * ERSTELLEN *. Ein Feld wird angezeigt, das Ihre Anwendung darstellt:

image: https://assets.digitalocean.com/articles/cart_64920/Argo_CD_3.png [Argo CD-ANWENDUNGEN Seite mit rsvpapp]

Nach * Status: * sehen Sie, dass Ihre Anwendung * OutOfSync * mit Ihrem GitHub-Repository ist. Klicken Sie zum Bereitstellen Ihrer Anwendung auf GitHub auf * AKTIONEN * und wählen Sie * Synchronisieren *. Nach einigen Augenblicken ändert sich Ihr Anwendungsstatus in "Synchronisiert", was bedeutet, dass Argo CD Ihre Anwendung bereitgestellt hat.

Klicken Sie nach der Bereitstellung Ihrer Anwendung auf das Anwendungsfeld, um ein detailliertes Diagramm Ihrer Anwendung anzuzeigen:

image: https: //assets.digitalocean.com/articles/cart_64920/Argo_CD_Application_Details.png [Argo CD-Anwendungsdetailseite für rsvpapp]

Um diese Bereitstellung in Ihrem Kubernetes-Cluster zu finden, wechseln Sie zurück zum Terminalfenster Ihres Remote-Servers und geben Sie Folgendes ein:

kubectl get pod

Sie erhalten die Ausgabe mit den Pods, auf denen Ihre App ausgeführt wird:

OutputNAME                      READY     STATUS    RESTARTS   AGE
rsvp-755d87f66b-hgfb5     1/1       Running   0          12m
rsvp-755d87f66b-p2bsh     1/1       Running   0          12m
rsvp-db-54996bf89-gljjz   1/1       Running   0          12m

Überprüfen Sie als Nächstes die Dienste:

kubectl get svc

Neben der Nummer des Ports, über den Ihre App ausgeführt wird, finden Sie einen Dienst für die RSVP-App und Ihre MongoDB-Datenbank, der im Folgenden hervorgehoben wird:

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        2h
mongodb      ClusterIP   10.102.150.54   <none>        27017/TCP      25m
rsvp         NodePort    10.106.91.108   <none>        80:/TCP   25m

Sie können Ihre implementierte RSVP-App finden, indem Sie in Ihrem Browser zu "+: +" navigieren und die oben hervorgehobene Nummer verwenden, um:

image: https: //assets.digitalocean.com/articles/cart_64920/RSVP_App.png [RSVP Application]

Nachdem Sie Ihre Anwendung mit Argo CD bereitgestellt haben, können Sie Ihr Continuous Deployment-System testen und so anpassen, dass es automatisch mit GitHub synchronisiert wird.

Schritt 4 - Testen des Setups für die kontinuierliche Bereitstellung

Testen Sie mit der Installation von Argo CD Ihr Continuous Deployment-System, indem Sie Änderungen an Ihrem Projekt vornehmen und eine neue Erstellung Ihrer Anwendung auslösen.

Navigieren Sie in Ihrem Browser zu "+ https: // github.com // rsvpapp-webinar4 ", klicken Sie in den Zweig "* master *" und aktualisieren Sie die Datei " k8s / rsvp.yaml ", um Ihre App mit dem erstellten Image bereitzustellen von CircleCI als Basis. Fügen Sie " dev " nach " image: nkhare / rsvpapp: +" hinzu, wie im Folgenden gezeigt:

rsvpapp-webinar2 / k8s / rsvp.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: rsvp
spec:
 replicas: 2
 selector:
   matchLabels:
     app: rsvp
 template:
   metadata:
     labels:
       app: rsvp
   spec:
     containers:
     - name: rsvp-app
       image: nkhare/rsvpapp:
       imagePullPolicy: Always
       livenessProbe:
         httpGet:
           path: /
           port: 5000
         periodSeconds: 30
         timeoutSeconds: 1
         initialDelaySeconds: 50
       env:
       - name: MONGODB_HOST
         value: mongodb
       ports:
       - containerPort: 5000
         name: web-port
. . .

Anstatt das ursprüngliche Image von Docker Hub abzurufen, verwendet Argo CD jetzt das im Continuous Integration-System erstellte * dev * -Image, um die Anwendung zu erstellen.

Übernehmen Sie die Änderung und kehren Sie zur ArgoCD-Benutzeroberfläche zurück. Sie werden feststellen, dass sich noch nichts geändert hat. Dies liegt daran, dass Sie die automatische Synchronisierung nicht aktiviert haben und die Anwendung manuell synchronisieren müssen.

Um die Anwendung manuell zu synchronisieren, klicken Sie auf den blauen Kreis oben rechts auf dem Bildschirm und klicken Sie auf * Sync *. Es erscheint ein neues Menü mit einem Feld zur Bezeichnung Ihrer neuen Revision und einem Kontrollkästchen mit der Bezeichnung * PRUNE *:

image: https://assets.digitalocean.com/articles/cart_64920/Argo_CD_Sync_Page.png [Synchronisierungsseite für Argo-CD]

Durch Aktivieren dieses Kontrollkästchens wird sichergestellt, dass die veraltete Version zerstört wird, sobald Argo CD Ihre neue Anwendung startet. Klicken Sie auf das Kästchen * PRUNE * und dann oben auf dem Bildschirm auf * SYNCHRONIZE *. Sie werden sehen, wie sich die alten Elemente Ihrer Anwendung und die neuen Elemente mit Ihrem von CircleCI erstellten Image drehen. Wenn das neue Bild Änderungen enthält, finden Sie diese neuen Änderungen in Ihrer Anwendung unter der URL "+: +".

Wie bereits erwähnt, verfügt Argo CD auch über eine automatische Synchronisierungsoption, die Änderungen in Ihre Anwendung einbezieht, sobald Sie sie vornehmen. Öffnen Sie dazu Ihr Terminal für Ihren Remote-Server und verwenden Sie den folgenden Befehl:

argocd app set  --sync-policy automated

Um sicherzustellen, dass Revisionen nicht versehentlich gelöscht werden, ist die Standardeinstellung für die automatische Synchronisierung deaktiviert. Um die automatische Bereinigung zu aktivieren, fügen Sie einfach das Flag "+ - Auto-Prune +" am Ende des vorhergehenden Befehls hinzu.

Nachdem Sie Ihrem Kubernetes-Cluster Continuous Deployment-Funktionen hinzugefügt haben, haben Sie die Demonstration des GitOps CI / CD-Systems mit CircleCI und Argo CD abgeschlossen.

Fazit

In diesem Tutorial haben Sie mit CircleCI eine Pipeline erstellt, die Tests auslöst und aktualisierte Bilder erstellt, wenn Sie den Code in Ihrem GitHub-Repository ändern. Sie haben Argo CD auch zum Bereitstellen einer Anwendung verwendet, wobei die von CircleCI integrierten Änderungen automatisch übernommen wurden. Mit diesen Tools können Sie jetzt Ihr eigenes GitOps CI / CD-System erstellen, das Git als Organisationsthema verwendet.

Wenn Sie mehr über Git erfahren möchten, besuchen Sie unsere Tutorialserie An Introduction to Open Source. Weitere Informationen zu DevOps-Tools, die in Git-Repositorys integriert sind, finden Sie unter How So installieren und konfigurieren Sie GitLab unter Ubuntu 18.04.

Related