diff --git a/docs/books/learning_ansible/00-toc.de.md b/docs/books/learning_ansible/00-toc.de.md index 1a6c533594..9045a08888 100644 --- a/docs/books/learning_ansible/00-toc.de.md +++ b/docs/books/learning_ansible/00-toc.de.md @@ -4,4 +4,4 @@ title: Ansible lernen mit Rocky Linux # Ansible lernen mit Rocky Linux -Ansible ist eine einfache, aber leistungsstarke Automatisierungs-Engine für GNU/Linux. Dieses Tutorial führt Sie durch die Konzepte der Verwendung von Ansible zur Automatisierung Ihrer IT-Aufgaben auf eine Weise, die (hoffentlich) unterhaltsam und informativ ist. Die Verwendung der Übungen in diesen Kapiteln wird Ihnen dabei helfen, sich mit Ansible und realistischen Anwendungen vertraut zu machen. +Ansible ist eine einfache, aber leistungsstarke Automatisierungs-Engine für GNU/Linux. Dieses Tutorial führt Sie durch die Konzepte der Verwendung von Ansible zur Automatisierung Ihrer IT-Aufgaben auf eine Weise, die (hoffentlich) unterhaltsam und informativ ist. Die Verwendung der Übungen in diesen Kapiteln wird Ihnen dabei helfen, sich mit Ansible und realistischen Anwendungen vertraut zu machen.

🌐 Übersetzungen: crowdin.com/project/rockydocs
🌍 Übersetzer: rockydocs/activity-stream , rockylinux.org
🖋 Mitmachen: github.com/rocky-linux diff --git a/docs/books/web_services/00-toc.de.md b/docs/books/web_services/00-toc.de.md index d1a40244a4..b2e166f721 100644 --- a/docs/books/web_services/00-toc.de.md +++ b/docs/books/web_services/00-toc.de.md @@ -27,4 +27,15 @@ Die Zielgruppe dieses Buches sind Systemadministratoren, die bereits in der Verw Dieses Buch ist als Trainingshandbuch konzipiert, so dass es auf verschiedene Arten eingesetzt werden kann. Es kann als Schulungsmittel für Trainer oder als Selbstlernhilfe für Administratoren verwendet werden, die neue Fähigkeiten erwerben oder ihr vorhandenes Wissen vertiefen möchten. -Zur Implementierung einiger der in diesem Buch vorgestellten Dienste benötigen Sie möglicherweise zwei (oder mehr) Server, um die Theorie in die Praxis umsetzen zu können. +Zur Implementierung einiger der in diesem Buch vorgestellten Dienste benötigen Sie möglicherweise zwei (oder mehr) Server, um die Theorie in die Praxis umsetzen zu können. +

+🌐 Übersetzungen: +crowdin.com/project/rockydocs +
+🌍 Übersetzer: +rockydocs/activity-stream +, rockylinux.org +
+🖋 Mitmachen: +github.com/rocky-linux + diff --git a/docs/index.de.md b/docs/index.de.md index 3838d411e4..6221accd06 100644 --- a/docs/index.de.md +++ b/docs/index.de.md @@ -54,4 +54,4 @@ Wenn Sie nicht weiter kommen oder Fragen haben, ist die Rocky Linux Community da ## Mitwirkung -Haben Sie festgestellt, dass etwas fehlt? Haben Sie einen Fehler gefunden? Sie fragen sich, wie Sie ein eigenes Dokument erstellen oder wie Sie etwas hier reparieren oder anpassen können? Haben wir nicht gesagt, dass *Sie*, wenn Sie möchten, Teil der Rocky Linux Community sind? Nun, das bedeutet, dass *Sie* für uns wichtig sind und wir gern möchten, dass Sie sich uns anschließen und helfen diese Dokumentation zu verbessern. Wenn Sie daran interessiert sind, schauen Sie im [Contribution Guide](https://github.com/rocky-linux/documentation/blob/main/README.md) nach!

🌐 Translations: crowdin.com/project/rockydocs
🌍 Translators: rockydocs/activity-stream , rockylinux.org
🖋 Contributors: github.com/rocky-linux +Haben Sie festgestellt, dass etwas fehlt? Haben Sie einen Fehler gefunden? Sie fragen sich, wie Sie ein eigenes Dokument erstellen oder wie Sie etwas hier reparieren oder anpassen können? Haben wir nicht gesagt, dass *Sie*, wenn Sie möchten, Teil der Rocky Linux Community sind? Nun, das bedeutet, dass *Sie* für uns wichtig sind und wir gern möchten, dass Sie sich uns anschließen und helfen diese Dokumentation zu verbessern. Wenn Sie daran interessiert sind, schauen Sie im [Contribution Guide](https://github.com/rocky-linux/documentation/blob/main/README.md) nach!

🌐 Übersetzungen: crowdin.com/project/rockydocs
🌍 Übersetzer: rockydocs/activity-stream , rockylinux.org
🖋 Mitmachen: github.com/rocky-linux diff --git a/docs/labs/kubernetes-the-hard-way/lab0-README.de.md b/docs/labs/kubernetes-the-hard-way/lab0-README.de.md index 80de276dc6..6b53d843c5 100644 --- a/docs/labs/kubernetes-the-hard-way/lab0-README.de.md +++ b/docs/labs/kubernetes-the-hard-way/lab0-README.de.md @@ -12,7 +12,18 @@ contributors: Steven Spencer, Ganna Zhyrnova Dieses Tutorial führt Sie durch die anspruchsvolle Einrichtung von Kubernetes. Es ist nicht für jemanden geeignet, der nach einem vollständig automatisierten Tool zum Einrichten eines Kubernetes-Clusters sucht. `Kubernetes The Hard Way` ist zum Lernen konzipiert. Sie müssen also den langen Weg gehen, um sicherzustellen, dass Sie jede Aufgabe verstehen, die zum Bootstrapping eines Kubernetes-Clusters erforderlich ist. -Betrachten Sie die Ergebnisse dieses Tutorials nicht als produktionsreif und es wird möglicherweise keine Unterstützung von der Community erhalten, aber lassen Sie sich dadurch nicht vom Lernen abhalten! +Betrachten Sie die Ergebnisse dieses Tutorials nicht als produktionsreif und es wird möglicherweise keine Unterstützung von der Community erhalten, aber lassen Sie sich dadurch nicht vom Lernen abhalten! +

+🌐 Übersetzungen: +crowdin.com/project/rockydocs +
+🌍 Übersetzer: +rockydocs/activity-stream +, rockylinux.org +
+🖋 Mitmachen: +github.com/rocky-linux + ## Copyright @@ -45,10 +56,10 @@ Für dieses Tutorial sind vier (4) x86_64-basierte virtuelle oder physische Masc - [Provisionierung der CA und Generierung von TLS-Zertifikate](lab4-certificate-authority.md) - [Generierung der Kubernetes Konfigurationsdateien für die Authentifizierung](lab5-kubernetes-configuration-files.md) - [Generierung der Data Encryption Konfiguration und Schlüssel](lab6-data-encryption-keys.md) -- [Bootstrapping vom etcd-Cluster](lab7-bootstrapping-etcd.md) -- [Bootstrapping the Kubernetes Control Plane](lab8-bootstrapping-kubernetes-controllers.md) -- [Bootstrapping the Kubernetes Worker Nodes](lab9-bootstrapping-kubernetes-workers.md) -- [Configuring kubectl for Remote Access](lab10-configuring-kubectl.md) -- [Provisioning Pod Network Routes](lab11-pod-network-routes.md) -- [Smoke Test](lab12-smoke-test.md) +- [Bootstrapping vom `etcd`-Cluster](lab7-bootstrapping-etcd.md) +- [Bootstrapping der Kubernetes Kontrollebene](lab8-bootstrapping-kubernetes-controllers.md) +- [Bootstrapping der Kubernetes Worker-Knoten](lab9-bootstrapping-kubernetes-workers.md) +- [Konfiguration von `kubectl` für Remote-Zugriff](lab10-configuring-kubectl.md) +- [Bereitstellung von Pod-Netzwerkrouten](lab11-pod-network-routes.md) +- [Smoke-Test](lab12-smoke-test.md) - [Cleaning Up](lab13-cleanup.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab0-README.fr.md b/docs/labs/kubernetes-the-hard-way/lab0-README.fr.md index 92cb8e367d..1f1ab85200 100644 --- a/docs/labs/kubernetes-the-hard-way/lab0-README.fr.md +++ b/docs/labs/kubernetes-the-hard-way/lab0-README.fr.md @@ -10,9 +10,19 @@ contributors: Steven Spencer, Ganna Zhyrnova Il s'agit d'un fork de l'original ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) écrit à l'origine par Kelsey Hightower (GitHub : kelseyhightower). Contrairement à l'original, qui se base sur des distributions de type Debian pour l'architecture ARM64, ce fork cible les distributions Enterprise Linux telles que Rocky Linux, qui fonctionne sur l'architecture x86_64. -Ce tutoriel vous guide dans la configuration de Kubernetes à la dure. Ce n’est pas pour quelqu’un qui recherche un outil entièrement automatisé pour configurer une grappe Cluster Kubernetes. `Kubernetes The Hard Way` est conçu pour l'apprentissage, cela signifie donc prendre le long chemin pour vous assurer de comprendre chaque tâche requise pour démarrer un cluster Kubernetes. - -Ne considérez pas les résultats de ce tutoriel comme prêts pour la production, et il se peut qu'il ne reçoive pas le soutien de la communauté, mais ne laissez pas cela vous empêcher d'apprendre ! +Ce tutoriel vous guide dans la configuration de Kubernetes pas à pas. Ce n’est pas pour quelqu’un qui recherche un outil entièrement automatisé pour configurer une grappe Cluster Kubernetes. `Kubernetes The Hard Way` est conçu pour l'apprentissage, cela signifie donc prendre le long chemin pour vous assurer de comprendre chaque tâche requise pour démarrer un cluster Kubernetes. + +Ne considérez pas les résultats de ce tutoriel comme prêts pour la production, et il se peut qu'il ne reçoive pas le soutien de la communauté, mais ne laissez pas cela vous empêcher d'apprendre ! +

+🌐 Traductions: +crowdin.com/project/rockydocs +
+🌍 Traducteurs: +rockydocs/activity-stream +
+🖋 Contributeurs: +github.com/rocky-linux + ## Droits d'auteur @@ -41,14 +51,14 @@ Ce tutoriel nécessite quatre (4) machines virtuelles ou physiques basées sur x - [Prérequis](lab1-prerequisites.md) - [Mise en Place de Jumpbox](lab2-jumpbox.md) -- [Provisioning Compute Resources](lab3-compute-resources.md) -- [Provisioning the CA and Generating TLS Certificates](lab4-certificate-authority.md) -- [Generating Kubernetes Configuration Files for Authentication](lab5-kubernetes-configuration-files.md) -- [Generating the Data Encryption Config and Key](lab6-data-encryption-keys.md) -- [Bootstrapping the etcd Cluster](lab7-bootstrapping-etcd.md) -- [Bootstrapping the Kubernetes Control Plane](lab8-bootstrapping-kubernetes-controllers.md) -- [Bootstrapping the Kubernetes Worker Nodes](lab9-bootstrapping-kubernetes-workers.md) -- [Configuring kubectl for Remote Access](lab10-configuring-kubectl.md) -- [Provisioning Pod Network Routes](lab11-pod-network-routes.md) +- [Provisionnement des Resources de Calcul](lab3-compute-resources.md) +- [Provisionnement de CA et Génération de Certificats TLS](lab4-certificate-authority.md) +- [Génération des Fichiers de Configuration Kubernetes pour l'Authentification](lab5-kubernetes-configuration-files.md) +- [Génération de la Configuration et de Clé de Chiffrement des Données](lab6-data-encryption-keys.md) +- [Amorçage du Cluster `etcd`](lab7-bootstrapping-etcd.md) +- [Amorçage du Plan de Contrôle Kubernetes](lab8-bootstrapping-kubernetes-controllers.md) +- [Amorçage des nœuds de travail Kubernetes](lab9-bootstrapping-kubernetes-workers.md) +- [Configuration de `kubectl` pour l'Accès à Distance](lab10-configuring-kubectl.md) +- [Provisionnement de Routes Réseau des `pod`s](lab11-pod-network-routes.md) - [Smoke Test](lab12-smoke-test.md) - [Cleaning Up](lab13-cleanup.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.fr.md b/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.fr.md index d070fa40b0..6ceea7a6d6 100644 --- a/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.fr.md +++ b/docs/labs/kubernetes-the-hard-way/lab1-prerequisites.fr.md @@ -7,7 +7,7 @@ tags: - exercice d'atelier --- -# Labo n°1 : Prérequis +# Atelier n°1 : Prérequis !!! info diff --git a/docs/labs/kubernetes-the-hard-way/lab10-configuring-kubectl.de.md b/docs/labs/kubernetes-the-hard-way/lab10-configuring-kubectl.de.md new file mode 100644 index 0000000000..79a479799e --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab10-configuring-kubectl.de.md @@ -0,0 +1,96 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer +tags: + - kubernetes + - k8s + - Laborübung + - runc + - containerd + - etcd + - kubectl +--- + +# Labor 7: Bootstrapping des `etcd`-Clusters + +!!! info + + Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft. + +In diesem Labor generieren Sie basierend auf den Benutzeranmeldeinformationen `admin` eine Kubeconfig-Datei für das Befehlszeilenprogramm `kubectl`. + +> Führen Sie Befehle in diesem Abschnitt aus der `jumpbox` aus. + +## The Admin Kubernetes Configuration File + +Für jede Kubeconfig ist ein Kubernetes-API-Server zur Verbindung erforderlich. + +Basierend auf dem DNS-Eintrag „/etc/hosts“ aus einem früheren Labor sollten Sie in der Lage sein, „server.kubernetes.local“ anzupingen. + +```bash +curl -k --cacert ca.crt \ + https://server.kubernetes.local:6443/version +``` + +```text +{ + "major": "1", + "minor": "32", + "gitVersion": "v1.32.0", + "gitCommit": "70d3cc986aa8221cd1dfb1121852688902d3bf53", + "gitTreeState": "clean", + "buildDate": "2024-12-11T17:59:15Z", + "goVersion": "go1.23.3", + "compiler": "gc", + "platform": "linux/amd64" +} +``` + +Generieren Sie eine Kubeconfig-Datei, die für die Authentifizierung als `admin`-Benutzer geeignet ist: + +```bash + kubectl config set-cluster kubernetes-the-hard-way \ + --certificate-authority=ca.crt \ + --embed-certs=true \ + --server=https://server.kubernetes.local:6443 + + kubectl config set-credentials admin \ + --client-certificate=admin.crt \ + --client-key=admin.key + + kubectl config set-context kubernetes-the-hard-way \ + --cluster=kubernetes-the-hard-way \ + --user=admin + + kubectl config use-context kubernetes-the-hard-way +``` + +Die Ergebnisse der Ausführung des obigen Befehls sollten eine Kubeconfig-Datei am Standardspeicherort `~/.kube/config` erstellen, der vom Befehlszeilentool `kubectl` verwendet wird. Dies bedeutet auch, dass Sie den Befehl `kubectl` ausführen können, ohne eine Konfiguration anzugeben. + +## Verifizierung + +Überprüfen Sie die Version des Remote-Kubernetes-Clusters: + +```bash +kubectl version +``` + +```text +Client Version: v1.32.0 +Kustomize Version: v5.5.0 +Server Version: v1.32.0 +``` + +Listen Sie die Knoten im Remote-Kubernetes-Cluster auf: + +```bash +kubectl get nodes +``` + +```text +NAME STATUS ROLES AGE VERSION +node-0 Ready 30m v1.31.2 +node-1 Ready 35m v1.31.2 +``` + +Fortsetzung folgt: [Provisionierung der Pod-Netzwerk-Routen](lab11-pod-network-routes.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab11-pod-network-routes.fr.md b/docs/labs/kubernetes-the-hard-way/lab11-pod-network-routes.fr.md new file mode 100644 index 0000000000..4af23bdfe8 --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab11-pod-network-routes.fr.md @@ -0,0 +1,94 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - exercice d'atelier + - runc + - containerd + - etcd + - kubectl +--- + +# Atelier n°11 : Provisionnement des routes réseau des pods + +!!! info + + Il s'agit d'un fork de l'original ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) écrit à l'origine par Kelsey Hightower (GitHub : kelseyhightower). Contrairement à l'original, qui se base sur des distributions de type Debian pour l'architecture ARM64, ce fork cible les distributions Enterprise Linux telles que Rocky Linux, qui fonctionne sur l'architecture x86_64. + +Les pods planifiés sur un nœud reçoivent une adresse IP de la plage CIDR du pod du nœud. Actuellement, les pods ne peuvent pas communiquer avec d’autres pods exécutés sur des nœuds différents en raison de l’absence de [routes] réseau(https://cloud.google.com/compute/docs/vpc/routes). + +Dans cet atelier, vous allez créer un itinéraire pour chaque nœud de travail qui mappe la plage CIDR du pod du nœud à l'adresse IP interne du nœud. + +> Il existe [d'autres façons](https://kubernetes.io/docs/concepts/cluster-administration/networking/#how-to-achieve-this) d'implémenter le modèle de réseau Kubernetes. + +## Table de Routage + +Dans cette section, vous rassemblerez les informations nécessaires pour créer des itinéraires dans le réseau VPC `kubernetes-the-hard-way`. + +Affichez l'adresse IP interne et la plage CIDR du pod pour chaque instance de travail : + +```bash +{ + SERVER_IP=$(grep server machines.txt | cut -d " " -f 1) + NODE_0_IP=$(grep node-0 machines.txt | cut -d " " -f 1) + NODE_0_SUBNET=$(grep node-0 machines.txt | cut -d " " -f 5) + NODE_1_IP=$(grep node-1 machines.txt | cut -d " " -f 1) + NODE_1_SUBNET=$(grep node-1 machines.txt | cut -d " " -f 5) +} +``` + +```bash +ssh root@server <U>.| +00000150 80 3a 39 d5 08 f9 6c de 6b 0a |.:9...l.k.| +0000015a +``` + +Sie müssen dem Schlüssel `etcd` das Präfix `k8s:enc:aescbc:v1:key1` voranstellen, was darauf hinweist, dass Sie den Anbieter `aescbc` verwenden, um die Daten mit dem Verschlüsselungsschlüssel `key1` zu verschlüsseln. + +## Bereitstellungen + +In diesem Abschnitt überprüfen Sie die Fähigkeit zum Erstellen und Verwalten von [Bereitstellungen —deployments—](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/). + +Erstellen Sie eine Bereitstellung —`deployment`— für den [nginx](https://nginx.org/en/)-Webserver: + +```bash +kubectl create deployment nginx \ + --image=nginx:latest +``` + +Listen Sie den durch die `nginx`-Bereitstellung erstellten Pod auf: + +```bash +kubectl get pods -l app=nginx +``` + +```bash +NAME READY STATUS RESTARTS AGE +nginx-54c98b4f84-dfwl9 1/1 Running 0 71s +``` + +### Port-Weiterleitung + +In diesem Abschnitt überprüfen Sie die Möglichkeit, per Remotezugriff auf Anwendungen mithilfe der [Portweiterleitung](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/) zuzugreifen. + +Rufen Sie den vollständigen Namen des `nginx`-Pods ab: + +```bash +POD_NAME=$(kubectl get pods -l app=nginx \ + -o jsonpath="{.items[0].metadata.name}") +``` + +Leiten Sie Port `8080` auf Ihrem lokalen Computer an Port `80` des `nginx`-Pods weiter: + +```bash +kubectl port-forward $POD_NAME 8080:80 +``` + +```text +Forwarding from 127.0.0.1:8080 -> 80 +Forwarding from [::1]:8080 -> 80 +``` + +Stellen Sie in einem neuen Terminal eine HTTP-Anfrage mit der Weiterleitungsadresse: + +```bash +curl --head http://127.0.0.1:8080 +``` + +```text +HTTP/1.1 200 OK +Server: nginx/1.27.4 +Date: Tue, 04 Mar 2025 01:30:20 GMT +Content-Type: text/html +Content-Length: 615 +Last-Modified: Wed, 05 Feb 2025 11:06:32 GMT +Connection: keep-alive +ETag: "67a34638-267" +Accept-Ranges: bytes +``` + +Wechseln Sie zurück zum vorherigen Terminal und stoppen Sie die Portweiterleitung zum `nginx`-Pod, indem Sie ++ctrl+c++ eingeben: + +```text +Forwarding from 127.0.0.1:8080 -> 80 +Forwarding from [::1]:8080 -> 80 +Handling connection for 8080 +^C +``` + +### Logs + +In diesem Abschnitt überprüfen Sie die Möglichkeit, [Containerprotokolle abzurufen](https://kubernetes.io/docs/concepts/cluster-administration/logging/). + +Drucken Sie die `nginx`-Pod-Protokolle: + +```bash +kubectl logs $POD_NAME +``` + +```text +...... +127.0.0.1 - - [04/Mar/2025:01:30:20 +0000] "HEAD / HTTP/1.1" 200 0 "-" "curl/7.76.1" "-" +``` + +### Exec + +In diesem Abschnitt überprüfen Sie die Fähigkeit, [Befehle in einem Container auszuführen](https://kubernetes.io/docs/tasks/debug-application-cluster/get-shell-running-container/#running-individual-commands-in-a-container). + +Drucken Sie die `nginx`-Version, indem Sie den Befehl `nginx -v` im `nginx`-Container ausführen: + +```bash +kubectl exec -ti $POD_NAME -- nginx -v +``` + +```text +nginx version: nginx/1.27.4 +``` + +## Dienste + +In diesem Abschnitt überprüfen Sie die Möglichkeit, Anwendungen mit einem [Dienst](https://kubernetes.io/docs/concepts/services-networking/service/) verfügbar zu machen. + +Stellen Sie die `nginx`-Bereitstellung mithilfe eines [NodePort](https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport)-Dienstes bereit: + +```bash +kubectl expose deployment nginx \ + --port 80 --type NodePort +``` + +> Sie können den Diensttyp `LoadBalancer` nicht verwenden, da Ihr Cluster nicht mit der [Cloud-Provider-Integration](https://kubernetes.io/docs/getting-started-guides/scratch/#cloud-provider) konfiguriert ist. Dieses Tutorial behandelt nicht die Einrichtung der Cloud-Anbieter-Integration. + +Rufen Sie den dem Dienst `nginx` zugewiesenen Knotenport ab: + +```bash +NODE_PORT=$(kubectl get svc nginx \ + --output=jsonpath='{range .spec.ports[0]}{.nodePort}') +``` + +Stellen Sie eine HTTP-Anfrage mit der IP-Adresse und dem `nginx`-Knotenport: + +```bash +curl -I http://node-0:${NODE_PORT} +``` + +```text +HTTP/1.1 200 OK +Server: nginx/1.27.4 +Date: Tue, 04 Mar 2025 01:40:20 GMT +Content-Type: text/html +Content-Length: 615 +Last-Modified: Wed, 05 Feb 2025 11:06:32 GMT +Connection: keep-alive +ETag: "67a34638-267" +Accept-Ranges: bytes +``` + +Weiter: [Aufräumen](lab13-cleanup.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab12-smoke-test.fr.md b/docs/labs/kubernetes-the-hard-way/lab12-smoke-test.fr.md new file mode 100644 index 0000000000..2cd8714097 --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab12-smoke-test.fr.md @@ -0,0 +1,206 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - exercice d'atelier + - runc + - containerd + - etcd + - kubectl +--- + +# Atelier n°12: Smoke Test + +!!! info + + Il s'agit d'un fork de l'original ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) écrit à l'origine par Kelsey Hightower (GitHub : kelseyhightower). Contrairement à l'original, qui se base sur des distributions de type Debian pour l'architecture ARM64, ce fork cible les distributions Enterprise Linux telles que Rocky Linux, qui fonctionne sur l'architecture x86_64. + +Dans cet atelier, vous effectuerez des tâches pour vous assurer du bon fonctionnement de votre `cluster` Kubernetes. + +## Chiffrement des Données + +Dans cette section, vous vérifierez la capacité de [crypter les données secrètes au repos](https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/#verifying-that-data-is-encrypted). + +Créer un secret générique : + +```bash +kubectl create secret generic kubernetes-the-hard-way \ + --from-literal="mykey=mydata" +``` + +Imprimez un hexdump du secret `kubernetes-the-hard-way` stocké dans `etcd` : + +```bash +ssh root@server \ + 'etcdctl get /registry/secrets/default/kubernetes-the-hard-way | hexdump -C' +``` + +```text +00000000 2f 72 65 67 69 73 74 72 79 2f 73 65 63 72 65 74 |/registry/secret| +00000010 73 2f 64 65 66 61 75 6c 74 2f 6b 75 62 65 72 6e |s/default/kubern| +00000020 65 74 65 73 2d 74 68 65 2d 68 61 72 64 2d 77 61 |etes-the-hard-wa| +00000030 79 0a 6b 38 73 3a 65 6e 63 3a 61 65 73 63 62 63 |y.k8s:enc:aescbc| +00000040 3a 76 31 3a 6b 65 79 31 3a 67 64 d4 64 d9 6c eb |:v1:key1:gd.d.l.| +00000050 f3 a9 80 8c 82 a0 f3 50 e6 eb 02 cb a6 65 8b 51 |.......P.....e.Q| +00000060 0a 03 2f ef 4a a8 d9 7d 62 f5 68 27 74 1c 6d 88 |../.J..}b.h't.m.| +00000070 ee 89 39 8d c9 e4 c6 2c 9c 3f 55 3b eb 79 2c 55 |..9....,.?U;.y,U| +00000080 d9 47 ec 77 84 0b 6e b1 ab 58 41 22 1e c3 7c 00 |.G.w..n..XA"..|.| +00000090 92 ad ad d0 97 55 f4 d5 b6 1e 6d 57 fb 2f 7c 36 |.....U....mW./|6| +000000a0 f5 6a 45 5e a7 a4 70 52 1d 9d 00 61 14 cd f3 92 |.jE^..pR...a....| +000000b0 9a 05 57 dd cf 41 1c 74 0c a7 2c ac 64 f5 79 51 |..W..A.t..,.d.yQ| +000000c0 e6 5c 16 e1 a9 5e da 00 91 d0 f5 77 e2 32 8f a2 |.\...^.....w.2..| +000000d0 9a c3 26 50 f2 a0 f8 f9 95 09 20 29 f1 7c 7a 7d |..&P...... ).|z}| +000000e0 4f 82 0b 78 43 28 91 a1 56 ee 66 90 fb ac 26 8c |O..xC(..V.f...&.| +000000f0 a3 b4 b2 ed 2d 0a d3 54 d1 10 89 a4 c3 dd b6 2d |....-..T.......-| +00000100 b9 d7 98 bb db c4 0d f2 96 5a 57 8b 01 2e 97 43 |.........ZW....C| +00000110 ea 9c 8b cf cc 9b 80 cd 02 c8 c5 a4 e7 bf 62 73 |..............bs| +00000120 e6 6b e8 c2 cf 34 50 2b e0 3c 66 a2 29 4f 08 0c |.k...4P+.U>.| +00000150 80 3a 39 d5 08 f9 6c de 6b 0a |.:9...l.k.| +0000015a +``` + +Vous devez préfixer la clé `etcd` avec `k8s:enc:aescbc:v1:key1`, ce qui indique l'utilisation du fournisseur `aescbc` pour crypter les données avec la clé de cryptage `key1`. + +## Déploiements + +Dans cette section, vous vérifierez la capacité de créer et de gérer des [déploiements](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/). + +Créez un déploiement pour le serveur Web [nginx](https://nginx.org/en/) : + +```bash +kubectl create deployment nginx \ + --image=nginx:latest +``` + +Dressez la liste du pod créé par le déploiement `nginx` : + +```bash +kubectl get pods -l app=nginx +``` + +```bash +NAME READY STATUS RESTARTS AGE +nginx-54c98b4f84-dfwl9 1/1 Running 0 71s +``` + +### Redirection de port + +Dans cette section, vous vérifierez la possibilité d'accéder aux applications à distance à l'aide du [transfert de port](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/). + +Récupérer le nom complet du pod `nginx` : + +```bash +POD_NAME=$(kubectl get pods -l app=nginx \ + -o jsonpath="{.items[0].metadata.name}") +``` + +Transférez le port `8080` de votre machine locale vers le port `80` du pod `nginx` : + +```bash +kubectl port-forward $POD_NAME 8080:80 +``` + +```text +Forwarding from 127.0.0.1:8080 -> 80 +Forwarding from [::1]:8080 -> 80 +``` + +Dans un nouveau terminal, effectuez une requête HTTP avec l'adresse de transfert : + +```bash +curl --head http://127.0.0.1:8080 +``` + +```text +HTTP/1.1 200 OK +Server: nginx/1.27.4 +Date: Tue, 04 Mar 2025 01:30:20 GMT +Content-Type: text/html +Content-Length: 615 +Last-Modified: Wed, 05 Feb 2025 11:06:32 GMT +Connection: keep-alive +ETag: "67a34638-267" +Accept-Ranges: bytes +``` + +Retournez au terminal précédent et arrêtez la redirection de port vers le pod `nginx` en tapant ++ctrl+c++ : + +```text +Forwarding from 127.0.0.1:8080 -> 80 +Forwarding from [::1]:8080 -> 80 +Handling connection for 8080 +^C +``` + +### Journalisation + +Dans cette section, vous vérifierez la possibilité de [récupérer les journaux des conteneurs](https://kubernetes.io/docs/concepts/cluster-administration/logging/). + +Affichez les journaux du pod `nginx` : + +```bash +kubectl logs $POD_NAME +``` + +```text +...... +127.0.0.1 - - [04/Mar/2025:01:30:20 +0000] "HEAD / HTTP/1.1" 200 0 "-" "curl/7.76.1" "-" +``` + +### Exec + +Dans cette section, vous vérifierez la possibilité de [exécuter des commandes dans un conteneur](https://kubernetes.io/docs/tasks/debug-application-cluster/get-shell-running-container/#running-individual-commands-in-a-container). + +Imprimez la version `nginx` en exécutant la commande `nginx -v` dans le conteneur `nginx` : + +```bash +kubectl exec -ti $POD_NAME -- nginx -v +``` + +```text +nginx version : nginx/1.27.4 +``` + +## Services + +Dans cette section, vous vérifierez la possibilité d'exposer des applications avec un [Service](https://kubernetes.io/docs/concepts/services-networking/service/). + +Exposez le déploiement `nginx` à l'aide d'un service [NodePort](https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport) : + +```bash +kubectl expose deployment nginx \ + --port 80 --type NodePort +``` + +> Vous ne pouvez pas utiliser le type de service `LoadBalancer` car votre cluster n'est pas configuré avec [l'intégration du fournisseur cloud](https://kubernetes.io/docs/getting-started-guides/scratch/#cloud-provider). Ce tutoriel ne couvre pas la configuration de l'intégration du fournisseur cloud. + +Récupérer le port du nœud attribué au service `nginx` : + +```bash +NODE_PORT=$(kubectl get svc nginx \ + --output=jsonpath='{range .spec.ports[0]}{.nodePort}') +``` + +Effectuez une requête HTTP avec l'adresse IP et le port du nœud `nginx` : + +```bash +curl -I http://node-0:${NODE_PORT} +``` + +```text +HTTP/1.1 200 OK +Server: nginx/1.27.4 +Date: Tue, 04 Mar 2025 01:40:20 GMT +Content-Type: text/html +Content-Length: 615 +Last-Modified: Wed, 05 Feb 2025 11:06:32 GMT +Connection: keep-alive +ETag: "67a34638-267" +Accept-Ranges: bytes +``` + +Next: [Cleaning Up](lab13-cleanup.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab13-cleanup.de.md b/docs/labs/kubernetes-the-hard-way/lab13-cleanup.de.md new file mode 100644 index 0000000000..3996a6381b --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab13-cleanup.de.md @@ -0,0 +1,24 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - Laborübung +--- + +# Labor 13: Aufräumen + +!!! info + + Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft. + +Sie werden die während dieses Lernprogramms in diesem Labor erstellten Rechenressourcen löschen. + +## Rechner-Instanzen + +Frühere Versionen dieses Handbuchs verwendeten GCP-Ressourcen für verschiedene Aspekte der Datenverarbeitung und Vernetzung. Die aktuelle Version ist agnostisch; Sie führen alle Konfigurationen auf der `jumpbox`, dem `server` oder den Knoten durch. + +Das Aufräumen ist so einfach wie das Löschen aller virtuellen Maschinen, die Sie für diese Übung erstellt haben. + +Next: [Start Over](lab0-README.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab13-cleanup.fr.md b/docs/labs/kubernetes-the-hard-way/lab13-cleanup.fr.md new file mode 100644 index 0000000000..edb52d5f07 --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab13-cleanup.fr.md @@ -0,0 +1,24 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - exercice d'atelier +--- + +# Atelier n°13 : Nettoyage + +!!! info + + Il s'agit d'un fork de l'original ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way) écrit à l'origine par Kelsey Hightower (GitHub : kelseyhightower). Contrairement à l'original, qui se base sur des distributions de type Debian pour l'architecture ARM64, ce fork cible les distributions Enterprise Linux telles que Rocky Linux, qui fonctionne sur l'architecture x86_64. + +Vous aller supprimer les ressources de calcul créées au cours de ce tutoriel dans cet atelier. + +## Instances de Calcul + +Les versions précédentes de ce guide utilisaient les ressources GCP pour divers aspects de l'informatique et des réseaux. La version actuelle est agnostique ; vous effectuez toutes les configurations sur le serveur `jumpbox`, le serveur `server` ou les nœuds. + +Le nettoyage est aussi simple que de supprimer toutes les machines virtuelles que vous avez créées pour cet exercice. + +Next: [Start Over](lab0-README.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md index 91af0fe898..5031c68f83 100644 --- a/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md +++ b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.de.md @@ -7,7 +7,7 @@ tags: - Laborübung --- -# Übung 2: Einrichten der Jumpbox +# Labor 2: Einrichten der Jumpbox !!! info diff --git a/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.fr.md b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.fr.md index 229d0a1272..7b6d7aa669 100644 --- a/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.fr.md +++ b/docs/labs/kubernetes-the-hard-way/lab2-jumpbox.fr.md @@ -7,7 +7,7 @@ tags: - exercice d'atelier --- -# Atelier n°2 : Mise en Place de The Jumpbox +# Atelier n°2 : Mise en Place du Serveur `The Jumpbox` !!! info diff --git a/docs/labs/kubernetes-the-hard-way/lab3-compute-resources.de.md b/docs/labs/kubernetes-the-hard-way/lab3-compute-resources.de.md new file mode 100644 index 0000000000..ae70f640b5 --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab3-compute-resources.de.md @@ -0,0 +1,236 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer +tags: + - kubernetes + - k8s + - Laborübung +--- + +# Labor 3: Bereitstellen von Rechenressourcen + +!!! info + + Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft. + +Kubernetes erfordert eine Reihe von Maschinen zum Hosten der Kubernetes-Steuerebene und der Worker-Knoten, auf denen die Container letztendlich ausgeführt werden. In diesem Labor stellen Sie die zum Einrichten eines Kubernetes-Clusters erforderlichen Maschinen bereit. + +## Maschinen-Datenbank + +In diesem Lernprogramm wird eine Textdatei genutzt, die als Maschinendatenbank dient, um die verschiedenen Maschinenattribute zu speichern, die Sie beim Einrichten der Kubernetes-Steuerebene und der Worker-Knoten verwenden. Das folgende Schema stellt Einträge in der Maschinendatenbank dar, ein Eintrag pro Zeile: + +```text +IPV4_ADDRESS FQDN HOSTNAME POD_SUBNET +``` + +Jede Spalte entspricht einer Maschinen-IP-Adresse `IPV4_ADDRESS`, einem vollqualifizierten Domänennamen `FQDN`, einem Hostnamen `HOSTNAME` und dem IP-Subnetz `POD_SUBNET`. Kubernetes weist pro `Pod` eine IP-Adresse zu und `POD_SUBNET` stellt den eindeutigen IP-Adressbereich dar, der jeder Maschine im Cluster hierfür zugewiesen wird. + +Hier ist ein Beispiel für eine Maschinendatenbank, die der Datenbank ähnelt, die zum Erstellen dieses Tutorials verwendet wurde. Bitte werfen Sie einen Blick auf die versteckten IP -Adressen. Sie können Ihren Maschinen jede beliebige IP-Adresse zuweisen, sofern diese untereinander und über die `jumpbox` erreichbar sind. + +```bash +cat machines.txt +``` + +```text +XXX.XXX.XXX.XXX server.kubernetes.local server +XXX.XXX.XXX.XXX node-0.kubernetes.local node-0 10.200.0.0/24 +XXX.XXX.XXX.XXX node-1.kubernetes.local node-1 10.200.1.0/24 +``` + +Jetzt sind Sie an der Reihe, eine `machines.txt`-Datei mit den Details zu den drei Maschinen zu erstellen, die Sie zum Erstellen Ihres Kubernetes-Clusters verwenden werden. Sie können die Beispielmaschinendatenbank von oben verwenden, um die Details für Ihre Maschinen hinzuzufügen. + +## Konfiguration des SSH-Zugriffs + +Sie verwenden SSH, um die Maschinen im Cluster zu konfigurieren. Stellen Sie sicher, dass Sie über SSH-Zugriff als `root` auf alle in Ihrer Maschinendatenbank aufgeführten Maschinen verfügen. Möglicherweise müssen Sie den Root-SSH-Zugriff auf jedem Knoten aktivieren, indem Sie die Datei `sshd_config` aktualisieren und den SSH-Server neu starten. + +### Aktivierung vom Root-SSH-Zugriff + +Sie können diesen Abschnitt überspringen, wenn Sie für jeden Ihrer Computer über SSH-Zugriff als `root` verfügen. + +Eine neue `Rocky Linux`-Installation deaktiviert standardmäßig den SSH-Zugriff für den `root`-Benutzer. Dies geschieht aus Sicherheitsgründen, da der `root`-Benutzer die vollständige administrative Kontrolle über Unix-ähnliche Systeme hat. Schwache Passwörter sind für mit dem Internet verbundene Maschinen untragbar. Wie bereits erwähnt, aktivieren Sie den `root`-Zugriff über SSH, um die Schritte in diesem Tutorial zu optimieren. Sicherheit ist ein Kompromiss; in diesem Fall optimieren Sie auf Komfort. + +Melden Sie sich mit SSH und Ihrem Benutzerkonto bei jedem Computer an und wechseln Sie dann mit dem Befehl `su` zum `root`-Benutzer: + +```bash +su - root +``` + +Bearbeiten Sie die SSH-Daemon-Konfigurationsdatei `/etc/ssh/sshd_config` und setzen Sie die Option `PermitRootLogin` auf `yes`: + +```bash +sed -i \ + 's/^#PermitRootLogin.*/PermitRootLogin yes/' \ + /etc/ssh/sshd_config +``` + +Starten Sie den SSH-Server `sshd` neu, um die aktualisierte Konfigurationsdatei abzurufen: + +```bash +systemctl restart sshd +``` + +### Generierung und Verteilung der SSH-Schlüssel + +Hier generieren und verteilen Sie ein SSH-Schlüsselpaar an die Maschinen `server`, `node-0` und `node-1`, das Sie im Verlauf dieses Lernprogramms zum Ausführen von Befehlen auf diesen Maschinen verwenden werden. Führen Sie die folgenden Befehle vom `jumpbox`-Rechner aus. + +Generieren Sie einen neuen SSH-Schlüssel: + +```bash +ssh-keygen +``` + +Drücken Sie ++enter++, um alle Standardwerte für die Eingabeaufforderungen hier zu akzeptieren: + +```text +Generating public/private rsa key pair. +Enter file in which to save the key (/root/.ssh/id_rsa): +Enter passphrase (empty for no passphrase): +Enter same passphrase again: +Your identification has been saved in /root/.ssh/id_rsa +Your public key has been saved in /root/.ssh/id_rsa.pub +``` + +Kopieren Sie den öffentlichen SSH-Schlüssel auf jeden Computer: + +```bash +while read IP FQDN HOST SUBNET; do + ssh-copy-id root@${IP} +done < machines.txt +``` + +Nachdem Sie jeden Schlüssel hinzugefügt haben, überprüfen Sie, ob der SSH-Zugriff mit öffentlichem Schlüssel funktioniert: + +```bash +while read IP FQDN HOST SUBNET; do + ssh -n root@${IP} uname -o -m +done < machines.txt +``` + +```text +x86_64 GNU/Linux +x86_64 GNU/Linux +x86_64 GNU/Linux +``` + +## Hostnamen + +In diesem Abschnitt weisen Sie den Maschinen `server`, `node-0` und `node-1` Hostnamen zu. Sie verwenden den Hostnamen, wenn Sie Befehle von der `jumpbox` an die einzelnen Maschinen ausführen. Auch innerhalb des Clusters spielt der Hostname eine große Rolle. Anstatt dass Kubernetes-Clients eine IP-Adresse verwenden, um Befehle an den Kubernetes-API-Server zu senden, verwenden diese Clients stattdessen den Hostnamen `server`. Hostnamen werden auch von jeder Arbeitsmaschine, `node-0` und `node-1`, bei der Registrierung bei einem bestimmten Kubernetes-Cluster verwendet. + +Um den Hostnamen für jede Maschine zu konfigurieren, führen Sie die folgenden Befehle auf der `jumpbox` aus. + +Legen Sie den Hostnamen auf jedem Computer fest, der in der Datei `machines.txt` aufgeführt ist: + +```bash +while read IP FQDN HOST SUBNET; do + ssh -n root@${IP} cp /etc/hosts /etc/hosts.bak + CMD="sed -i 's/^127.0.0.1.*/127.0.0.1\t${FQDN} ${HOST}/' /etc/hosts" + ssh -n root@${IP} "$CMD" + ssh -n root@${IP} hostnamectl hostname ${HOST} +done < machines.txt +``` + +Überprüfen Sie den auf jedem Computer eingerichteten Hostnamen: + +```bash +while read IP FQDN HOST SUBNET; do + ssh -n root@${IP} hostname --fqdn +done < machines.txt +``` + +```text +server.kubernetes.local +node-0.kubernetes.local +node-1.kubernetes.local +``` + +## Host-Lookup-Tabelle + +In diesem Abschnitt generieren Sie eine `hosts`-Datei und hängen sie an die Datei `/etc/hosts` auf `jumpbox` und an die `/etc/hosts`-Dateien auf allen drei Cluster-Mitgliedern an, die für dieses Tutorial verwendet werden. Dadurch ist jede Maschine über einen Hostnamen wie `server`, `node-0` oder `node-1` erreichbar. + +Erstellen Sie eine neue „Hosts“-Datei und fügen Sie einen Header hinzu, um die hinzugefügten Maschinen zu identifizieren: + +```bash +echo "" > hosts +echo "# Kubernetes The Hard Way" >> hosts +``` + +Erstellen Sie für jede Maschine einen Host-Eintrag in der Datei `machines.txt` und hängen Sie ihn an die Datei `hosts` an: + +```bash +while read IP FQDN HOST SUBNET; do + ENTRY="${IP} ${FQDN} ${HOST}" + echo $ENTRY >> hosts +done < machines.txt +``` + +Review the host entries in the `hosts` file: + +```bash +cat hosts +``` + +```text + +# Kubernetes The Hard Way +XXX.XXX.XXX.XXX server.kubernetes.local server +XXX.XXX.XXX.XXX node-0.kubernetes.local node-0 +XXX.XXX.XXX.XXX node-1.kubernetes.local node-1 +``` + +## Hinzufügen von `/etc/hosts`-Einträgen zu einem lokalen Computer + +In diesem Abschnitt hängen Sie die DNS-Einträge aus der Datei `hosts` an die lokale Datei `/etc/hosts` auf Ihrem `jumpbox`-Computer an. + +Hängen Sie die DNS-Einträge von `hosts` an `/etc/hosts` an: + +```bash +cat hosts >> /etc/hosts +``` + +Überprüfen Sie die Aktualisierung der Datei `/etc/hosts`: + +```bash +cat /etc/hosts +``` + +```text +127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4 +::1 localhost localhost.localdomain localhost6 localhost6.localdomain6 + +# Kubernetes The Hard Way +XXX.XXX.XXX.XXX server.kubernetes.local server +XXX.XXX.XXX.XXX node-0.kubernetes.local node-0 +XXX.XXX.XXX.XXX node-1.kubernetes.local node-1 +``` + +Sie sollten in der Lage sein, mit jedem in der Datei `machines.txt` aufgeführten Computer über einen Hostnamen eine SSH-Verbindung herzustellen. + +```bash +for host in server node-0 node-1 + do ssh root@${host} uname -o -m -n +done +``` + +```text +server x86_64 GNU/Linux +node-0 x86_64 GNU/Linux +node-1 x86_64 GNU/Linux +``` + +## Hinzufügen von `/etc/hosts`-Einträgen zu den Remote-Maschinen + +In diesem Abschnitt hängen Sie die Host-Einträge von `hosts` an `/etc/hosts` auf jedem Computer an, der in der Textdatei `machines.txt` aufgeführt ist. + +Kopieren Sie die Datei `hosts` auf jeden Computer und hängen Sie den Inhalt an `/etc/hosts` an: + +```bash +while read IP FQDN HOST SUBNET; do + scp hosts root@${HOST}:~/ + ssh -n \ + root@${HOST} "cat hosts >> /etc/hosts" +done < machines.txt +``` + +Sie können Hostnamen verwenden, wenn Sie von Ihrer `jumpbox`-Maschine oder einer der drei Maschinen im Kubernetes-Cluster eine Verbindung zu Maschinen herstellen. Anstatt IP-Adressen zu verwenden, können Sie jetzt eine Verbindung zu Maschinen herstellen, indem Sie einen Hostnamen wie `server`, `node-0` oder `node-1` verwenden. + +Weiter mit: [Bereitstellung einer CA und Generieren von TLS-Zertifikaten](lab4-certificate-authority.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab4-certificate-authority.de.md b/docs/labs/kubernetes-the-hard-way/lab4-certificate-authority.de.md index b5adcfc4bd..14f2fee5d7 100644 --- a/docs/labs/kubernetes-the-hard-way/lab4-certificate-authority.de.md +++ b/docs/labs/kubernetes-the-hard-way/lab4-certificate-authority.de.md @@ -7,7 +7,7 @@ tags: - Laborübung --- -# Übung 4: Bereitstellung einer Zertifizierungsstelle und Generieren von TLS-Zertifikaten +# Labor 4: Bereitstellung einer Zertifizierungsstelle und Generieren von TLS-Zertifikaten !!! info @@ -56,7 +56,7 @@ ca.crt ca.key !!! tip "Hinweis" Um die in der generierten Zertifikatsdatei (`ca.crt`) codierten Details anzuzeigen, können Sie diesen OpenSSL-Befehl verwenden: - `openssl x509 -in ca.crt -text -noout | less`.\ + `openssl x509 -in ca.crt -text -noout | less`. ## Erstellen von Client- und Serverzertifikaten diff --git a/docs/labs/kubernetes-the-hard-way/lab5-kubernetes-configuration-files.de.md b/docs/labs/kubernetes-the-hard-way/lab5-kubernetes-configuration-files.de.md new file mode 100644 index 0000000000..041787cd5a --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab5-kubernetes-configuration-files.de.md @@ -0,0 +1,214 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - Laborübung +--- + +# Labor 5: Generierung von Kubernetes-Konfigurationsdateien zur Authentifizierung + +!!! info + + Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft. + +In diesem Labor generieren Sie [Kubernetes-Client-Konfigurationsdateien](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/), die normalerweise als `kubeconfigs` bezeichnet werden. Diese Dateien konfigurieren Kubernetes-Clients für die Verbindung mit Kubernetes-API-Servern und die Authentifizierung bei diesen. + +## Client-Authentifizierungskonfigurationen + +In diesem Abschnitt generieren Sie Kubeconfig-Dateien für den Benutzer `kubelet` und `admin`. + +### Die `kubelet` Kubernetes-Konfigurationsdatei + +Beim Generieren von Kubeconfig-Dateien für Kubelets müssen Sie das Client-Zertifikat mit dem Knotennamen des Kubelets abgleichen. Dadurch wird sichergestellt, dass Kubelets ordnungsgemäß vom Kubernetes [Node Authorizer](https://kubernetes.io/docs/reference/access-authn-authz/node/) autorisiert werden. + +> Die folgenden Befehle müssen im selben Verzeichnis ausgeführt werden, das zum Generieren der SSL-Zertifikate während des Labors [Generieren von TLS-Zertifikaten](lab4-certificate-authority.md) verwendet wurde. + +Generieren Sie eine Kubeconfig-Datei für die Worker-Knoten `node-0` und `node-1`: + +```bash +for host in node-0 node-1; do + kubectl config set-cluster kubernetes-the-hard-way \ + --certificate-authority=ca.crt \ + --embed-certs=true \ + --server=https://server.kubernetes.local:6443 \ + --kubeconfig=${host}.kubeconfig + + kubectl config set-credentials system:node:${host} \ + --client-certificate=${host}.crt \ + --client-key=${host}.key \ + --embed-certs=true \ + --kubeconfig=${host}.kubeconfig + + kubectl config set-context default \ + --cluster=kubernetes-the-hard-way \ + --user=system:node:${host} \ + --kubeconfig=${host}.kubeconfig + + kubectl config use-context default \ + --kubeconfig=${host}.kubeconfig +done +``` + +Ergebnisse: + +```text +node-0.kubeconfig +node-1.kubeconfig +``` + +### Die `kube-proxy` Kubernetes-Konfigurationsdatei + +Generieren Sie eine Kubeconfig-Datei für den Dienst `kube-proxy`: + +```bash + kubectl config set-cluster kubernetes-the-hard-way \ + --certificate-authority=ca.crt \ + --embed-certs=true \ + --server=https://server.kubernetes.local:6443 \ + --kubeconfig=kube-proxy.kubeconfig + + kubectl config set-credentials system:kube-proxy \ + --client-certificate=kube-proxy.crt \ + --client-key=kube-proxy.key \ + --embed-certs=true \ + --kubeconfig=kube-proxy.kubeconfig + + kubectl config set-context default \ + --cluster=kubernetes-the-hard-way \ + --user=system:kube-proxy \ + --kubeconfig=kube-proxy.kubeconfig + + kubectl config use-context default \ + --kubeconfig=kube-proxy.kubeconfig +``` + +Ergebnisse: + +```text +kube-proxy.kubeconfig +``` + +### Die Kubernetes-Konfigurationsdatei `kube-controller-manager` + +Generieren Sie eine Kubeconfig-Datei für den Dienst `kube-controller-manager`: + +```bash + kubectl config set-cluster kubernetes-the-hard-way \ + --certificate-authority=ca.crt \ + --embed-certs=true \ + --server=https://server.kubernetes.local:6443 \ + --kubeconfig=kube-controller-manager.kubeconfig + + kubectl config set-credentials system:kube-controller-manager \ + --client-certificate=kube-controller-manager.crt \ + --client-key=kube-controller-manager.key \ + --embed-certs=true \ + --kubeconfig=kube-controller-manager.kubeconfig + + kubectl config set-context default \ + --cluster=kubernetes-the-hard-way \ + --user=system:kube-controller-manager \ + --kubeconfig=kube-controller-manager.kubeconfig + + kubectl config use-context default \ + --kubeconfig=kube-controller-manager.kubeconfig +``` + +Ergebnisse: + +```text +kube-controller-manager.kubeconfig +``` + +### Die Kubernetes-Konfigurationsdatei `kube-scheduler` + +Generieren Sie eine Kubeconfig-Datei für den Dienst `kube-scheduler`: + +```bash + kubectl config set-cluster kubernetes-the-hard-way \ + --certificate-authority=ca.crt \ + --embed-certs=true \ + --server=https://server.kubernetes.local:6443 \ + --kubeconfig=kube-scheduler.kubeconfig + + kubectl config set-credentials system:kube-scheduler \ + --client-certificate=kube-scheduler.crt \ + --client-key=kube-scheduler.key \ + --embed-certs=true \ + --kubeconfig=kube-scheduler.kubeconfig + + kubectl config set-context default \ + --cluster=kubernetes-the-hard-way \ + --user=system:kube-scheduler \ + --kubeconfig=kube-scheduler.kubeconfig + + kubectl config use-context default \ + --kubeconfig=kube-scheduler.kubeconfig +``` + +Ergebnisse: + +```text +kube-scheduler.kubeconfig +``` + +### Die Kubernetes-Konfigurationsdatei des Administrators + +Generieren Sie eine Kubeconfig-Datei für den Benutzer `admin`: + +```bash + kubectl config set-cluster kubernetes-the-hard-way \ + --certificate-authority=ca.crt \ + --embed-certs=true \ + --server=https://127.0.0.1:6443 \ + --kubeconfig=admin.kubeconfig + + kubectl config set-credentials admin \ + --client-certificate=admin.crt \ + --client-key=admin.key \ + --embed-certs=true \ + --kubeconfig=admin.kubeconfig + + kubectl config set-context default \ + --cluster=kubernetes-the-hard-way \ + --user=admin \ + --kubeconfig=admin.kubeconfig + + kubectl config use-context default \ + --kubeconfig=admin.kubeconfig +``` + +Ergebnisse: + +```text +admin.kubeconfig +``` + +## Verteilen der Kubernetes-Konfigurationsdateien + +Kopieren Sie die Kubeconfig-Dateien `kubelet` und `kube-proxy` in die Instanzen `node-0` und `node-1`: + +```bash +for host in node-0 node-1; do + ssh root@$host "mkdir /var/lib/{kube-proxy,kubelet}" + + scp kube-proxy.kubeconfig \ + root@$host:/var/lib/kube-proxy/kubeconfig \ + + scp ${host}.kubeconfig \ + root@$host:/var/lib/kubelet/kubeconfig +done +``` + +Kopieren Sie die Kubeconfig-Dateien `kube-controller-manager` und `kube-scheduler` in die Controller-Instanz: + +```bash +scp admin.kubeconfig \ + kube-controller-manager.kubeconfig \ + kube-scheduler.kubeconfig \ + root@server:~/ +``` + +Fortsetzung folgt: [Konfiguration der Datenverschlüsselung]ä(lab6-data-encryption-keys.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab6-data-encryption-keys.de.md b/docs/labs/kubernetes-the-hard-way/lab6-data-encryption-keys.de.md index 2761023c4c..57e7d87000 100644 --- a/docs/labs/kubernetes-the-hard-way/lab6-data-encryption-keys.de.md +++ b/docs/labs/kubernetes-the-hard-way/lab6-data-encryption-keys.de.md @@ -7,7 +7,7 @@ tags: - Laborübung --- -# Übung 6: Generieren der Datenverschlüsselungskonfiguration und des Schlüssels +# Labor 6: Generierung der Datenverschlüsselungskonfiguration und Schlüssel !!! info diff --git a/docs/labs/kubernetes-the-hard-way/lab7-bootstrapping-etcd.de.md b/docs/labs/kubernetes-the-hard-way/lab7-bootstrapping-etcd.de.md new file mode 100644 index 0000000000..d8e8753125 --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab7-bootstrapping-etcd.de.md @@ -0,0 +1,96 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - Laborübung +--- + +# Labor 7: Bootstrapping des `etcd`-Clusters + +!!! info + + Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft. + +Kubernetes-Komponenten sind zustandslos und speichern den Clusterstatus in [etcd](https://github.com/etcd-io/etcd). In diesem Labor booten Sie einen `etcd`-Cluster mit drei Knoten und konfigurieren ihn für hohe Verfügbarkeit und sicheren Remotezugriff. + +## Voraussetzungen + +Kopieren Sie `etcd`-Binärdateien und `systemd`-Unit-Dateien in die `server`-Instanz: + +```bash +scp \ + downloads/etcd-v3.4.36-linux-amd64.tar.gz \ + units/etcd.service \ + root@server:~/ +``` + +Führen Sie die Befehle in den folgenden Abschnitten dieses Labors auf dem `server`-Computer aus. Melden Sie sich mit dem Befehl `ssh` beim `server`-Computer an. Beispiel: + +```bash +ssh root@server +``` + +## Bootstrapping eines `etcd`-Clusters + +### Installieren Sie die `etcd`-Binärdateien + +Wenn Sie es noch nicht installiert haben, installieren Sie zuerst das Dienstprogramm `tar` mit `dnf`. Extrahieren und installieren Sie dann den `etcd`-Server und das `etcdctl`-Befehlszeilenprogramm: + +```bash + dnf -y install tar + tar -xvf etcd-v3.4.36-linux-amd64.tar.gz + mv etcd-v3.4.36-linux-amd64/etcd* /usr/local/bin/ +``` + +### Konfigurieren Sie den `etcd`-Server + +```bash + mkdir -p /etc/etcd /var/lib/etcd + chmod 700 /var/lib/etcd + cp ca.crt kube-api-server.key kube-api-server.crt \ + /etc/etcd/ +``` + +Jedes `etcd`-Mitglied muss innerhalb eines `etcd`-Clusters einen eindeutigen Namen haben. Legen Sie den `etcd`-Namen so fest, dass er mit dem Hostnamen der aktuellen Compute-Instanz übereinstimmt: + +Erstellen Sie die `etcd.service` `systemd`-Unit-Datei: + +```bash +mv etcd.service /etc/systemd/system/ +chmod 644 /etc/systemd/system/etcd.service +``` + +!!! note "Anmerkung" + + Obwohl es als sicherheitsschädlich gilt, müssen Sie SELinux möglicherweise vorübergehend oder dauerhaft deaktivieren, wenn beim Starten des Dienstes `etcd` `systemd` Probleme auftreten. Die Lösung besteht darin, die erforderlichen Richtliniendateien mit Tools wie `ausearch`, `audit2allow` und anderen zu untersuchen und zu erstellen. + + Die folgenden Befehle entfernen SELinux und deaktivieren es: + + ```bash + sudo sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config + setenforce 0 + ``` + +### Starten Sie den `etcd`-Server + +```bash + systemctl daemon-reload + systemctl enable etcd + systemctl start etcd +``` + +## Verifizierung + +Listen Sie die `etcd`-Clustermitglieder auf: + +```bash +etcdctl member list +``` + +```text +6702b0a34e2cfd39, started, controller, http://127.0.0.1:2380, http://127.0.0.1:2379, false +``` + +Fortsetzung folgt: [Bootstrapping the Kubernetes Control Plane](lab8-bootstrapping-kubernetes-controllers.md) diff --git a/docs/labs/kubernetes-the-hard-way/lab8-bootstrapping-kubernetes-controllers.de.md b/docs/labs/kubernetes-the-hard-way/lab8-bootstrapping-kubernetes-controllers.de.md index a65a3f1278..965616488b 100644 --- a/docs/labs/kubernetes-the-hard-way/lab8-bootstrapping-kubernetes-controllers.de.md +++ b/docs/labs/kubernetes-the-hard-way/lab8-bootstrapping-kubernetes-controllers.de.md @@ -10,7 +10,7 @@ tags: - runc --- -# Übung 8: Bootstrapping der Kubernetes-Steuerebene +# Labor 8: Bootstrapping der Kubernetes-Steuerebene !!! info diff --git a/docs/labs/kubernetes-the-hard-way/lab9-bootstrapping-kubernetes-workers.de.md b/docs/labs/kubernetes-the-hard-way/lab9-bootstrapping-kubernetes-workers.de.md new file mode 100644 index 0000000000..3504b7889a --- /dev/null +++ b/docs/labs/kubernetes-the-hard-way/lab9-bootstrapping-kubernetes-workers.de.md @@ -0,0 +1,203 @@ +--- +author: Wale Soyinka +contributors: Steven Spencer, Ganna Zhyrnova +tags: + - kubernetes + - k8s + - Laborübung + - runc + - containerd + - etcd + - kubectl +--- + +# Labor 9: Bootstrapping der Kubernetes-Worker-Knoten + +!!! info + + Dies ist ein Fork des ursprünglichen ["Kubernetes the hard way"](https://github.com/kelseyhightower/kubernetes-the-hard-way), das ursprünglich von Kelsey Hightower geschrieben wurde (GitHub: kelseyhightower). Im Gegensatz zum Original, das auf Debian-ähnlichen Distributionen für die ARM64-Architektur basiert, zielt dieser Fork auf Enterprise-Linux-Distributionen wie Rocky Linux ab, das auf der x86_64-Architektur läuft. + +In diesem Labor werden Sie zwei Kubernetes-Workerknoten bootstrappen. Sie installieren die folgenden Komponenten: [runc](https://github.com/opencontainers/runc), [Container-Netzwerk-Plugins](https://github.com/containernetworking/cni), [containerd](https://github.com/containerd/containerd), [kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/) und [kube-proxy](https://kubernetes.io/docs/concepts/cluster-administration/proxies). + +## Voraussetzungen + +Kopieren Sie aus der `jumpbox` Kubernetes-Binärdateien und `systemd`-Unit-Dateien in jede Worker-Instanz: + +```bash +for host in node-0 node-1; do + SUBNET=$(grep $host machines.txt | cut -d " " -f 5) + sed "s|SUBNET|$SUBNET|g" \ + configs/10-bridge.conf > 10-bridge.conf + + sed "s|SUBNET|$SUBNET|g" \ + configs/kubelet-config.yaml > kubelet-config.yaml + + scp 10-bridge.conf kubelet-config.yaml \ + root@$host:~/ +done +``` + +```bash +for host in node-0 node-1; do + scp \ + downloads/runc.amd64 \ + downloads/crictl-v1.32.0-linux-amd64.tar.gz \ + downloads/cni-plugins-linux-amd64-v1.6.2.tgz \ + downloads/containerd-2.0.3-linux-amd64.tar.gz \ + downloads/kubectl \ + downloads/kubelet \ + downloads/kube-proxy \ + configs/99-loopback.conf \ + configs/containerd-config.toml \ + configs/kubelet-config.yaml \ + configs/kube-proxy-config.yaml \ + units/containerd.service \ + units/kubelet.service \ + units/kube-proxy.service \ + root@$host:~/ +done +``` + +Die Befehle in diesem Labor müssen auf jeder Workerinstanz separat ausgeführt werden: `node-0` und `node-1`. Es werden nur die Schritte für `node-0` beschrieben. Sie müssen die genauen Schritte und Befehle auf `node-1` wiederholen. + +Melden Sie sich mit dem Befehl `ssh` bei der Worker-Instanz `node-0` an. + +```bash +ssh root@node-0 +``` + +## Bereitstellen eines Kubernetes-Worker-Knotens + +Installieren Sie die Betriebssystemabhängigkeiten: + +```bash + dnf -y update + dnf -y install socat conntrack ipset tar +``` + +> Die Binärdatei `socat` unterstützt den Befehl `kubectl port-forward`. + +### Swap-Deaktivierung + +Wenn Sie [Swap](https://help.ubuntu.com/community/SwapFaq) aktiviert haben, kann das Kubelet nicht gestartet werden. Die [Empfehlung lautet, Swap zu deaktivieren](https://github.com/kubernetes/kubernetes/issues/7294), um sicherzustellen, dass Kubernetes eine angemessene Ressourcenzuweisung und Servicequalität bietet. + +Überprüfen Sie, ob der Swap aktiviert ist: + +```bash +swapon --show +``` + +Wenn die Ausgabe leer ist, ist der Swap nicht aktiviert. Wenn die Ausgabe nicht leer ist, führen Sie den folgenden Befehl aus, um den Swap sofort zu deaktivieren: + +```bash +swapoff -a +``` + +Um sicherzustellen, dass der Swap nach dem Neustart deaktiviert bleibt, kommentieren Sie die Zeile aus, die das Swap-Volume in der Datei `/etc/fstab` automatisch einbindet. Geben Sie bitte Folgendes ein: + +```bash +sudo sed -i '/swap/s/^/#/' /etc/fstab +``` + +Erstellen Sie die Installationsverzeichnisse: + +```bash +mkdir -p \ + /etc/cni/net.d \ + /opt/cni/bin \ + /var/lib/kubelet \ + /var/lib/kube-proxy \ + /var/lib/kubernetes \ + /var/run/kubernetes +``` + +Installieren Sie die Worker-Binärdateien: + +```bash + mkdir -p containerd + tar -xvf crictl-v1.32.0-linux-amd64.tar.gz + tar -xvf containerd-2.0.3-linux-amd64.tar.gz -C containerd + tar -xvf cni-plugins-linux-amd64-v1.6.2.tgz -C /opt/cni/bin/ + mv runc.amd64 runc + chmod +x crictl kubectl kube-proxy kubelet runc + mv crictl kubectl kube-proxy kubelet runc /usr/local/bin/ + mv containerd/bin/* /bin/ +``` + +### Konfigurieren des CNI-Netzwerks + +Erstellen Sie die Netzwerkkonfigurationsdatei `bridge`: + +```bash +mv 10-bridge.conf 99-loopback.conf /etc/cni/net.d/ +``` + +### Konfiguration von `containerd` + +Installieren Sie die `containerd`-Konfigurationsdateien: + +```bash + mkdir -p /etc/containerd/ + mv containerd-config.toml /etc/containerd/config.toml + mv containerd.service /etc/systemd/system/ +``` + +### Kubelet-Konfiguration + +Erstellen Sie die Konfigurationsdatei `kubelet-config.yaml`: + +```bash + mv kubelet-config.yaml /var/lib/kubelet/ + mv kubelet.service /etc/systemd/system/ +``` + +### Konfigurieren des Kubernetes-Proxys + +```bash + mv kube-proxy-config.yaml /var/lib/kube-proxy/ + mv kube-proxy.service /etc/systemd/system/ +``` + +!!! note "Anmerkung" + + Obwohl dies als unzureichende Sicherheit gilt, müssen Sie SELinux möglicherweise vorübergehend oder dauerhaft deaktivieren, wenn beim Starten der erforderlichen systemd-Dienste Probleme auftreten. Die richtige Lösung besteht darin, die erforderlichen Richtliniendateien mit Tools wie `ausearch`, `audit2allow` usw. zu analysieren und zu erstellen. + + Um SELinux zu entfernen und zu deaktivieren, gehen Sie wie folgt vor: + + ```bash + sudo sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config + setenforce 0 + ``` + +### Starten Sie die Worker-Dienste + +```bash + systemctl daemon-reload + systemctl enable containerd kubelet kube-proxy + systemctl start containerd kubelet kube-proxy +``` + +## Verifizierung + +Die in diesem Lernprogramm erstellten Compute-Instanzen verfügen nicht über die Berechtigung, diesen Überprüfungsabschnitt abzuschließen. Führen Sie die folgenden Befehle von der `jumpbox`-Maschine aus. + +Listen Sie die registrierten Kubernetes-Knoten auf: + +```bash +ssh root@server "kubectl get nodes --kubeconfig admin.kubeconfig" +``` + +```text +NAME STATUS ROLES AGE VERSION +node-0 Ready 1m v1.32.0 +``` + +Nachdem Sie alle vorherigen Schritte in diesem Labor sowohl auf `node-0` als auch auf `node-1` abgeschlossen haben, sollte die Ausgabe des Befehls `kubectl get nodes` Folgendes anzeigen: + +```text +NAME STATUS ROLES AGE VERSION +node-0 Ready 1m v1.32.0 +node-1 Ready 10s v1.32.0 +``` + +Fortsetzung folgt: [Konfiguration von kubectl für Remote-Access](lab10-configuring-kubectl.md)