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 entschieden haben, dass ihre Lösung nicht für unser Cluster geeignet ist, haben wir uns direkt in den Argo CD-Standardleitfaden “Getting started” gestürzt. Jetzt führen wir Euch durch den Einrichtungsvorgang von argoprojArgo CD auf k3s-iok3s und ciliumCilium, ausgehend vom Kapitel “Setup Certificate Manager with Cloudflare” unseres neuesten Beitrags “Setting up Kubernetes with Cilium and Cloudflare”. In genau diesem kürzlichen Beitrag haben wir auch keel-hqKeel am Ende aufgesetzt, aber dieser Schritt wird jetzt überflüssig, da wir Argo CD verwenden, um den neuesten Stand der Technik aus jedem githubGitHub-Repository zu beziehen. Viel Spaß beim Lesen!

Anforderungen

Bevor wir beginnen können, müssen wir sicherstellen, dass kubectl installiert ist, wir eine Kubeconfig-Datei haben (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 (überprüft, ob CoreDNS vorhanden ist, indem Ihr diesen

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

Befehl ausführt).

Installation

Zuerst wenden wir alle notwendigen Dienste, Deployments und viele andere verschiedene 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"

Wendet diese Ressource an, indem Ihr kubectl apply -f certificate.yaml ausführt.

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

Wendet diese Ressource an, indem Ihr kubectl apply -f argocd-ingress.yaml ausführt.

Deaktivieren von TSL in Argo CD

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

Um dies zu tun, führen wir zuerst diesen Befehl aus:

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

der hoffentlich eine Datei in vim oder neovim öffnet (alles andere wäre aus unserer Sicht unangenehm, LOL). Die Datei sollte wie folgt 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 zunächst nicht vorhanden sein, aber genau diese Einstellung möchten wir erreichen. Fügt diese beiden Zeilen (oben markiert) hinzu und speichert die Datei (Esc → :wq, wenn Ihr cool seid).

Startet den Argo CD-Server neu, indem Ihr diesen Befehl ausführt, und wartet, bis der 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 die Benutzeroberfläche unter https://argo-cd.trueberryless.org sehen (passwortgeschützt).

Argo CD UI-Dashboard

Manifest zum Repository hinzufügen

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

Wir empfehlen, einen neuen Ordner im Git-Repository zu erstellen, der etwas wie manifest heißt. In diesem Ordner legen wir ein paar Dateien an:

  • 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 die gleichen Dateien, die im anderen Beitrag erwähnt wurden, jedoch in vier Dateien aufgeteilt, da dies uns den Vorteil gibt, das Manifest von githubGitHub Actions aus zu manipulieren. Aber der Reihe nach, im nächsten Beitrag erfahrt Ihr, wie Ihr das Manifest mit GitHub Actions einrichtet.

Neue Anwendung in der Argo CD-Benutzeroberfläche erstellen

Ihr werdet wahrscheinlich den großen NEW APP-Button in der Benutzeroberfläche von argoprojArgo CD sehen. Klickt darauf und erstellt eine neue Anwendung mit den folgenden angepassten Eigenschaften:

  • Anwendungsname: mutanuq
  • Projektname: default
  • Sync-Policy: Mehr darüber erfahrt Ihr in diesem Beitrag / lasst es vorerst auf Manuell
  • Repository-URL: https://github.com/trueberryless-org/mutanuq
  • Revision: HEAD
  • Pfad: manifest
  • Cluster-URL: https://kubernetes.default.svc
  • Namespace: mutanuq

Optional — wenn Ihr die CLI installiert habt — könnt Ihr diesen Befehl für denselben Output 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, dass Ihre Website in der Benutzeroberfläche bereitgestellt wird. Dieser Vorgang kann einige Zeit in Anspruch nehmen, da beispielsweise die Zertifikatsanforderung genehmigt werden muss. Eine gesunde Anwendung sollte in etwa so aussehen:

Argo CD Beispiel-Anwendungs-UI

Mit einem Kaffee feiern!

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

Fortsetzung

Bleiben Sie dran für unseren nächsten Blog, in dem beschrieben wird, wie Sie ein githubGitHub-Repository einrichten, das anschließend über Argo CD bereitgestellt werden kann.

Stichwörter: