Zum Inhalt springen
Deep Thoughts

Einrichten von Argo CD in einem k3s-Cluster

Diese Übersetzung wurde von einer generativen KI mithilfe von Action Continuous Translation erstellt. →

A beautiful cover image with the text "Argo CD"
• Zuletzt aktualisiert: • 5 min Lesezeit • 800 Wörter
Felix Schneider
Felix Schneider
trueberryless

Nachdem wir Vegard S. Hagens Artikel “Argo CD Kustomize with Helm” gelesen und beschlossen haben, dass seine Lösung nicht passend für unseren Cluster ist, haben wir uns direkt in die Standard-Argo-CD-„Getting started“-Anleitung vertieft. Nun führen wir Sie durch die Herausforderungen bei der Einrichtung von argoprojArgo CD auf k3s-iok3s und ciliumCilium. Dies knüpft an das Kapitel „Setup Certificate Manager with Cloudflare“ aus unserem letzten Beitrag „Setting up Kubernetes with Cilium and Cloudflare“ an. In genau diesem Beitrag haben wir am Ende auch keel-hqKeel eingerichtet, aber dieser Schritt ist jetzt überflüssig, da wir Argo CD nutzen, um den neuesten Stand der Technik-Code aus jeder githubGitHub-Repo zu holen. Viel Spaß beim Lesen!

Voraussetzungen

Bevor wir starten, müssen wir sicherstellen, dass kubectl installiert ist, eine kubeconfig-Datei vorhanden ist (k3s speichert diese Datei hier:

/etc/rancher/k3s/config.yaml
flannel-backend: "none"
disable-kube-proxy: true
disable-network-policy: true
cluster-init: true
disable:
    - servicelb
    - traefik

) und CoreDNS (prüfen Sie, ob Sie CoreDNS haben, indem Sie diesen

Terminal-Fenster
kubectl get pods -n kube-system -l k8s-app=kube-dns

Befehl ausführen).

Installation

Zunächst wenden wir alle notwendigen Services, Deployments und viele andere Kubernetes-Ressourcen an, indem wir folgendes ausführen:

Terminal-Fenster
kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Zertifikat

Zusätzlich benötigen wir ein Zertifikat:

apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
    name: argocd
    namespace: argocd
spec:
    secretName: argocd
    issuerRef:
        name: acme-issuer
        kind: ClusterIssuer
    dnsNames:
        - "argo-cd.trueberryless.org"

Wenden Sie diese Ressource an, indem Sie kubectl apply -f certificate.yaml ausführen.

Ingress-Controller

Außerdem benötigen wir einen Ingress-Controller, der von Cilium verwaltet wird:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
    name: argocd-ingress
    namespace: argocd
spec:
    rules:
        - host: argo-cd.trueberryless.org
          http:
              paths:
                  - path: /
                    pathType: Prefix
                    backend:
                        service:
                            name: argocd-server
                            port:
                                number: 80


    tls:
        - hosts:
              - argo-cd.trueberryless.org
          secretName: argocd

Wenden Sie diese Ressource an, indem Sie kubectl apply -f argocd-ingress.yaml ausführen.

TLS in Argo CD deaktivieren

Mit dem Zertifikat ist die Verbindung zwischen Client und Server gesichert. Es gibt jedoch immer noch ein selbstsigniertes Zertifikat innerhalb der argoprojArgo CD-Services, das wir nicht unbedingt benötigen. Daher können wir die Sicherheit des Argo-CD-Servers deaktivieren, indem wir die Eigenschaft server.insecure bearbeiten.

Um das zu tun, führen wir zunächst diesen Befehl aus:

Terminal-Fenster
kubectl edit cm argocd-cmd-params-cm -n argocd

was hoffentlich eine Datei in vim oder neovim öffnet (ansonsten wäre es ziemlich unangenehm, wenn Sie uns fragen, LMAO). Die Datei sollte in etwa so aussehen:

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
data:
    server.insecure: "true"
kind: ConfigMap
metadata:
    annotations:
        kubectl.kubernetes.io/last-applied-configuration: |
            {"apiVersion":"v1","kind":"ConfigMap","metadata":{"annotations":{},"labels":{"app.kubernetes.io/name":"argocd-cmd-params-cm","app.kubernetes.io/part-of":"argocd"},"name":"arg
    creationTimestamp: "2024-07-27T11:15:28Z"
    labels:
        app.kubernetes.io/name: argocd-cmd-params-cm
        app.kubernetes.io/part-of: argocd
    name: argocd-cmd-params-cm
    namespace: argocd
    resourceVersion: "239710156"
    uid: 5f53d26b-3adf-4ed9-9807-c3da847335a2
data:
    server.insecure: "true"

Die letzten beiden Zeilen werden wahrscheinlich zuerst nicht vorhanden sein, aber genau diese Einstellung wollen wir erreichen. Fügen Sie diese beiden Zeilen (oben markiert) hinzu und speichern Sie die Datei (Esc → :wq, wenn Sie cool sind).

Starten Sie den Argo-CD-Server neu, indem Sie warten, bis das Rollout abgeschlossen ist:

Terminal-Fenster
kubectl rollout restart deploy argocd-server -n argocd
kubectl rollout status deploy argocd-server -n argocd

Nach all diesen Schritten sollten wir nun die Benutzeroberfläche unter https://argo-cd.trueberryless.org (passwortgeschützt) sehen.

Argo CD UI-Dashboard

Manifest im Repository hinzufügen

Um nun eine neue Anwendung in argoprojArgo CD zu erstellen (entweder über die Benutzeroberfläche oder CLI – wir nutzen die Benutzeroberfläche, da wir die CLI nicht eingerichtet haben), müssen wir das Git-Repository vorbereiten. Da das Repository die einzige Quelle der Wahrheit ist, definieren wir dort auch alle Kubernetes-Ressourcen, die von Argo CD erstellt werden sollen.

Wir empfehlen, im Git-Repository einen neuen Ordner mit dem Namen manifest zu erstellen. In diesem Ordner erstellen wir einige Dateien:

  • certificate.yaml:

    apiVersion: cert-manager.io/v1
    kind: Certificate
    metadata:
    name: mutanuq
    namespace: mutanuq
    spec:
    secretName: mutanuq
    issuerRef:
        name: acme-issuer
        kind: ClusterIssuer
    dnsNames:
        - "mutanuq.trueberryless.org"

  • deployment.yaml:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
        name: mutanuq
        namespace: mutanuq
        labels:
            app: mutanuq
    spec:
        replicas: 3
        selector:
            matchLabels:
                app: mutanuq
        template:
            metadata:
                labels:
                    app: mutanuq
            spec:
                containers:
                    - name: mutanuq
                    image: "trueberryless/mutanuq"
                    imagePullPolicy: Always

  • service.yaml:

    apiVersion: v1
    kind: Service
    metadata:
    name: mutanuq
    namespace: mutanuq
    annotations:
        cert-manager.io/issuer: acme-issuer
    spec:
    selector:
        app: mutanuq
    ports:
        - name: http
        port: 80

  • ingress.yaml:

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
    name: mutanuq
    namespace: mutanuq
    spec:
    rules:
        - host: mutanuq.trueberryless.org
        http:
            paths:
            - path: /
                pathType: Prefix
                backend:
                service:
                    name: mutanuq
                    port:
                    number: 80
    

    tls:
    - hosts:
        - mutanuq.trueberryless.org
        secretName: mutanuq

Diese Dateien sind im Grunde dieselben wie in dem anderen Beitrag, jedoch in vier Dateien aufgeteilt, da uns dies den Vorteil bietet, das Manifest aus githubGitHub-Aktionen heraus zu manipulieren. Aber der Reihe nach: Im nächsten Beitrag sehen Sie, wie das Manifest mit GitHub-Aktionen eingerichtet wird.

Neue Anwendung in der Argo-CD-Benutzeroberfläche erstellen

Sie werden wahrscheinlich den großen Button NEW APP in der Benutzeroberfläche von argoprojArgo CD sehen. Klicken Sie darauf und erstellen Sie eine neue Anwendung mit den unten angepassten Eigenschaften:

  • Anwendungsname: mutanuq
  • Projektname: default
  • Sync Policy: Erfahren Sie mehr in diesem Beitrag / vorerst auf Manual lassen
  • Repository-URL: https://github.com/trueberryless-org/mutanuq
  • Revision: HEAD
  • Pfad: manifest
  • Cluster-URL: https://kubernetes.default.svc
  • Namespace: mutanuq

Optional – wenn Sie die CLI installiert haben – können Sie diesen Befehl für dasselbe Ergebnis ausführen:

Terminal-Fenster
argocd app create mutanuq \
  --project default \
  --repo https://github.com/trueberryless-org/mutanuq \
  --revision HEAD \
  --path manifest \
  --dest-server https://kubernetes.default.svc \
  --dest-namespace mutanuq

Nun sollten Sie hoffentlich sehen, wie Ihre Website in der Benutzeroberfläche bereitgestellt wird. Dieser Prozess kann einige Zeit in Anspruch nehmen, da beispielsweise der Zertifikatsantrag genehmigt werden muss. Eine gesunde Anwendung sollte in etwa so aussehen:

Argo CD Beispiel-Anwendungs-UI

Feiern Sie mit einem Kaffee!

Herzlichen Glückwunsch, Sie haben erfolgreich argoprojArgo CD auf einem k3s-iok3s Cluster eingerichtet! Sie haben sich eine Kaffeepause verdient. Genießen Sie eine wohlverdiente Tasse, und wenn Sie mit mir virtuell einen Kaffee teilen möchten, können Sie gerne meine Arbeit auf Ko-fi unterstützen. Vielen Dank!

Fortsetzung

Fortsetzung in unserem nächsten Blog, der beschreibt, wie ein githubGitHub-Repository eingerichtet wird, das dann über Argo CD bereitgestellt werden kann.

Stichwörter: