1. WIP: Komplexe Pipelines

PlantUML Diagramm automatisch generieren mittels Docker Container / über pipeline?

Automatisches Update des Status mittels pipeline (Container in Subprojekt gefunden)?

1.1. Pipeline für / über mehrere Projekte

1.2. Master Repo mit verlinkten Projekten

Alle beteiligten Repos müssen ermittelt und aufgelistet werden

Berechtigungen müssen vorhanden sein oder eingerichtet werden!

Erforderlich für alle Sourcen und Artifact-Repos!

1.3. Pipeline Trigger? includes?

must be checked!

1.4. "Requirments" Check

configuration der Pfade mit den einzelnen Dockerfiles und erwarteten Versions-Tags? Oder autamatische Ermittlung?

1.5. Source to Image im Openschift für Entwicklung?

must be checked!

1.6. Repo für Infrastruktur Artifacts

coming soon

2. WIP: Aktuelle ToDos

2.1. Private

2.1.1. Ideen

2.1.2. Python

  • Verfügbare Versionen von Software-Projekten abfragen und in einer Übersicht anzeigen (am besten mit Datum der Veroffentlichung)

  • Benutzte / im Einsatz befindliche Versionen auf einer Übersicht anzeigen

  • Folgende Produkte sollten angezeigt werden (Gitlab / Gitlab-Runner, rke2, Rancher, Kubernetes, Harbor, AWX, Dokuwiki, ArgoCD, usw)

2.1.3. Gitlab

  • Gitlab runner auf Server mit docker compose

  • Docker Registry aktivieren

  • Gitlab runner in k8s installieren

  • Gitlab runner konfigurieren (extra helper image for arm64)

  • Gitlab runner in k8s testen

  • Gitlab runner - autoscaler?

  • Container Registry aktivieren für CI/CD

  • Gitlab komplexe Pipelines

  • Gitlab Pipeline import

  • Gitlab Pipeline über mehrere Projekte?

2.2. Rancher Server upgraden auf 2.6.9

2.3. Rancher Server auf rke2 und helm umstellen

Install rke2
1
2
3
4
5
6
7
# curl -sfL https://get.rke2.io | sh -

# Version for Rancher 2.6.6?
curl -sfL https://get.rke2.io | INSTALL_RKE2_VERSION=v1.26.13+rke2r1 sh -

systemctl enable rke2-server
systemctl start rke2-server
Install link to kubectl
1
2
3
4
5
ln -s /var/lib/rancher/rke2/bin/kubectl /usr/local/bin/kubectl
ln -s /var/lib/rancher/rke2/bin/kubectl /usr/local/bin/k

mkdir /root/.kube
ln -s /etc/rancher/rke2/rke2.yaml /root/.kube/config
Install Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
Add the Helm Chart Repository for Rancher
helm repo add rancher-stable https://releases.rancher.com/server-charts/stable
Create a Namespace for Rancher
kubectl create namespace cattle-system

2.3.1. Rancher mit Cert-Manager installieren

Install Cert-Manager (optional)
# If you have installed the CRDs manually instead of with the `--set installCRDs=true` option added to your Helm install command, you should upgrade your CRD resources before upgrading the Helm chart:
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.13.3/cert-manager.crds.yaml

# Add the Jetstack Helm repository
helm repo add jetstack https://charts.jetstack.io

# Update your local Helm chart repository cache
helm repo update

# Install the cert-manager Helm chart
helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace

# Show pods in cert-manager namespace
kubectl get pods --namespace cert-manager
Install Rancher with helm (optional)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
helm install rancher rancher-stable/rancher \
  --namespace cattle-system \
  --set hostname=rancher.siwczak.de \
  --set bootstrapPassword=admin \
  --set ingress.tls.source=letsEncrypt \
  --set letsEncrypt.email=thomas.siwczak@gmail.com \
  --set letsEncrypt.ingress.class=nginx \
  --set ingress.tls.source=letsEncrypt \
  --set replicas=1 \
  --version=2.7.5 \
  --set installCRDs=true

# Verify that the Rancher Server is Successfully Deployed
kubectl -n cattle-system rollout status deploy/rancher
kubectl -n cattle-system get deploy rancher
Set ingress.tls.source

For Let’s Encrypt - set Helm-Chart-Option:

`ingress.tls.source=letsEncrypt`

2.3.2. Rancher ohne Cert-Manager installieren

Secrets anlegen

3. WIP: Use Terraform and Ansible to setup K8s

3.1. Setup Terraform backend in gitlab

coming soon

3.2. Create Terraform project

coming soon

3.3. Create Ansible Playbook

coming soon

3.4.1. Install Helm

Install Helm (noch nicht optimal)
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

3.4.2. Install Argocd

Create namespace "argocd"
kubectl create ns argocd
Apply argocd install.yaml
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
Download argocd-cli with curl
curl -LO https://github.com/argoproj/argo-cd/releases/download/v2.10.0/argocd-linux-arm64
Install argocd-cli as "argocd"
sudo install -m 555 argocd-linux-arm64 /usr/local/bin/argocd
Patch argocd service to NodePort
kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "NodePort"}}'
Request the https nodePort port number
kubectl get svc argocd-server -n argocd -o jsonpath="{.spec.ports[1].nodePort}"
Get Initial-Admin-Password with kubectl
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d
Get Initial-Admin-Password with argocd-cli
argocd admin initial-password -n argocd
Login in argocd server with cli
argocd login <server-ip>:<nodePort>
Update Admin password with argocd-cli
argocd account update-password
Create Cluster
kubectl config get-contexts -o name
argocd cluster add <context-name>

4. Einstieg in DevOps

4.1. Einleitung

DevOps ist ein Begriff, der in der Softwareentwicklung immer mehr an Bedeutung gewinnt. Es handelt sich um eine Kultur, Methodik und einen Satz von Werkzeugen, die darauf abzielen, die Zusammenarbeit und Integration zwischen Entwicklungsteams (Dev) und Betriebsteams (Ops) zu verbessern. In diesem Blogpost werden wir uns näher mit dem Einstieg in DevOps beschäftigen und Schritte aufzeigen, wie Sie diese Praktiken erfolgreich implementieren können.

4.2. Was ist DevOps?

DevOps ist eine Philosophie, die auf der Idee basiert, dass Entwicklung und Betrieb nicht als getrennte Bereiche betrachtet werden sollten. Stattdessen sollten sie eng zusammenarbeiten, um Software effizienter bereitzustellen und kontinuierlich zu verbessern. DevOps fördert eine Kultur der Zusammenarbeit, Automatisierung und kontinuierlichen Überprüfung, um die Bereitstellung von Software schneller und stabiler zu machen.

4.3. Die Vorteile von DevOps

Die Einführung von DevOps bietet eine Vielzahl von Vorteilen für Organisationen. Einige der wichtigsten sind:

  1. Schnellere Bereitstellung: DevOps ermöglicht es Teams, Software schneller zu entwickeln und bereitzustellen. Durch die Automatisierung von Prozessen und die enge Zusammenarbeit zwischen Entwicklung und Betrieb können Softwareänderungen schnell getestet und implementiert werden.

  2. Höhere Qualität: Durch kontinuierliche Integration, automatisierte Tests und kontinuierliches Deployment können potenzielle Fehler frühzeitig erkannt und behoben werden. Dies führt zu einer insgesamt höheren Softwarequalität.

  3. Bessere Zusammenarbeit: DevOps fördert eine Kultur der Zusammenarbeit und Kommunikation zwischen Entwicklung und Betrieb. Durch den gemeinsamen Fokus auf die Bereitstellung von hochwertiger Software können Konflikte minimiert und die Produktivität gesteigert werden.

  4. Skalierbarkeit: DevOps ermöglicht es Organisationen, schnell auf sich ändernde Anforderungen und Kundenbedürfnisse zu reagieren. Durch die Automatisierung von Prozessen können Teams effizienter arbeiten und Softwarelösungen skalieren.

4.4. Der Einstieg in DevOps

Der Einstieg in DevOps erfordert eine schrittweise Herangehensweise und eine klare Strategie. Hier sind einige wichtige Schritte, die Sie berücksichtigen sollten:

4.4.1. Verständnis der DevOps-Prinzipien

Bevor Sie mit der Implementierung von DevOps beginnen, ist es wichtig, die zugrunde liegenden Prinzipien und Best Practices zu verstehen. Dazu gehören kontinuierliche Integration, kontinuierliches Deployment, Automatisierung, Testautomatisierung und kontinuierliches Monitoring. Informieren Sie sich über diese Konzepte und ihre Auswirkungen auf die Softwareentwicklung.

4.4.2. Schaffen Sie eine Kultur der Zusammenarbeit

DevOps erfordert eine enge Zusammenarbeit zwischen Entwicklungsteams, Betriebsteams und anderen relevanten Abteilungen. Schaffen Sie eine Kultur, die auf offener Kommunikation, Vertrauen und gemeinsamer Verantwortung basiert. Fördern Sie den Austausch von Wissen und Ideen zwischen den Teams und schaffen Sie Möglichkeiten für regelmäßige Meetings und Zusammenarbeit.

4.4.3. Automatisierung der Bereitstellung

Die Automatisierung spielt eine entscheidende Rolle in DevOps. Automatisieren Sie so viele Prozesse wie möglich, um die Effizienz und Geschwindigkeit der Bereitstellung von Software zu erhöhen. Automatisieren Sie beispielsweise den Build-Prozess, die Tests, das Deployment und das Monitoring. Verwenden Sie Werkzeuge wie Jenkins, Ansible oder Docker, um diese Aufgaben zu automatisieren.

4.4.4. Einsatz von Continuous Integration und Continuous Deployment

Die kontinuierliche Integration und das kontinuierliche Deployment sind Kernprinzipien von DevOps. Implementieren Sie eine Pipeline für die kontinuierliche Integration, um sicherzustellen, dass Codeänderungen regelmäßig und automatisch getestet werden. Verwenden Sie Tools wie Git, Jenkins und SonarQube, um den Prozess der kontinuierlichen Integration zu unterstützen. Für das kontinuierliche Deployment verwenden Sie Werkzeuge wie Kubernetes oder AWS Elastic Beanstalk, um die Software nahtlos und automatisch in die Produktionsumgebung zu übertragen.

4.4.5. Überwachung und Feedback

Eine kontinuierliche Überwachung ist unerlässlich, um die Leistung und Stabilität Ihrer Anwendungen zu gewährleisten. Implementieren Sie ein effektives Monitoring-System, das wichtige Metriken und Alarme erfasst. Verwenden Sie Werkzeuge wie Nagios, Grafana oder ELK Stack, um den Zustand Ihrer Anwendungen und Infrastruktur zu überwachen. Nutzen Sie das Feedback aus der Überwachung, um Verbesserungen vorzunehmen und Engpässe zu identifizieren.

4.4.6. Kontinuierliche Verbesserung

DevOps ist ein kontinuierlicher Prozess. Stellen Sie sicher, dass Sie regelmäßige Reviews und Retrospektiven durchführen, um den Fortschritt zu bewerten und Verbesserungspotenziale zu identifizieren. Nutzen Sie die gewonnenen Erkenntnisse, um den DevOps-Prozess weiter zu optimieren und effizienter zu gestalten.

4.5. Fazit

Der Einstieg in DevOps erfordert ein klares Verständnis der zugrunde liegenden Prinzipien und Best Practices sowie eine schrittweise Umsetzung. Durch die Schaffung einer Kultur der Zusammenarbeit, die Automatisierung von Prozessen und die kontinuierliche Integration und Bereitstellung können Organisationen die Vorteile von DevOps nutzen. Mit der richtigen Strategie und den geeigneten Tools können Sie Ihre Softwareentwicklung und Bereitstellung optimieren und qualitativ hochwertige Software effizienter liefern.

Beginnen Sie noch heute Ihren DevOps-Weg und erleben Sie die positiven Auswirkungen auf Ihre Organisation!

5. Kaniko

Einleitung, Anleitung und Beispiele

kaniko

5.1. Einleitung

Kaniko ist ein Open-Source-Tool, entwickelt von Google, das zum Bauen von Docker-Images innerhalb eines Kubernetes-Clusters oder einer anderen Umgebung ohne Docker Daemon verwendet wird. Es ermöglicht eine sichere und effiziente Erstellung von Container-Images direkt aus dem Quellcode.

5.2. Wie verwendet man Kaniko?

Um Kaniko zu nutzen, benötigen Sie zunächst eine Kubernetes-Umgebung. Sie können dann ein kaniko Pod in Ihrem Cluster starten, der auf Ihren Dockerfile zeigt und ein Image in Ihrer gewünschten Registry erstellt.

5.2.1. Schritte zur Verwendung von Kaniko

  1. Installieren Sie Kaniko in Ihrem Kubernetes-Cluster:

kubectl create -f https://github.com/GoogleContainerTools/kaniko/blob/master/deploy/Dockerfile
  1. Erstellen Sie eine geheime Datei für Ihre Registry:

kubectl create secret docker-registry regcred --docker-server=<your-registry-server> --docker-username=<your-name> --docker-password=<your-pword> --docker-email=<your-email>
  1. Verwenden Sie einen kaniko Pod, um Ihr Image zu erstellen:

apiVersion: v1
kind: Pod
metadata:
  name: kaniko
spec:
  containers:
  - name: kaniko
    image: gcr.io/kaniko-project/executor:latest
    args: ["--dockerfile=/Dockerfile",
           "--context=dir://<your-source-code>",
           "--destination=<your-registry>/<your-image>:<your-tag>"]
    volumeMounts:
      - name: kaniko-secret
        mountPath: /secret
        readOnly: true
    env:
      - name: GOOGLE_APPLICATION_CREDENTIALS
        value: /secret/kaniko-secret.json
  restartPolicy: Never
  volumes:
    - name: kaniko-secret
      secret:
        secretName: kaniko-secret

5.3. Beispiele

Nun, da Sie eine Vorstellung davon haben, wie man Kaniko verwendet, finden Sie hier einige Anwendungsfälle:

  1. Erstellen eines Python-Images: Wenn Sie einen Dockerfile haben, der auf ein Python-Image zeigt und Anforderungen aus einer requirements.txt-Datei installiert, können Sie Kaniko verwenden, um dieses Image effizient zu erstellen und es in Ihrer Registry bereitzustellen.

  2. Erstellen eines Java-Images: Ähnlich wie beim Python-Beispiel können Sie einen Dockerfile verwenden, der auf ein Java-Image zeigt und Ihre .jar-Datei in das Image kopiert. Kaniko kann dann verwendet werden, um dieses Image zu erstellen und es in Ihrer Registry bereitzustellen.

6. Packer.io

packer.io

6.1. Was ist Packer.io?

Packer.io ist eine kostenlose Open-Source-Tool zur Erstellung identischer Maschinenbilder für mehrere Plattformen aus einer einzigen Quellkonfiguration. Es wird von HashiCorp entwickelt, einem Unternehmen, das für die Entwicklung von Tools wie Vagrant, Terraform und Consul bekannt ist. Packer.io ist in der Programmiersprache Go geschrieben und kann auf mehreren Plattformen wie Linux, Windows und Mac OS X laufen.

6.2. Warum Packer.io verwenden?

Es gibt viele Gründe, warum Entwickler und Systemadministratoren Packer.io verwenden. Einige davon sind:

  • Konsistenz: Mit Packer.io können Sie Maschinenbilder erstellen, die auf allen Ihren Servern gleich sind. Dies verringert das Risiko von Fehlern und Vereinfacht die Fehlersuche.

  • Zeitersparnis: Mit Packer.io können Sie Maschinenbilder automatisch erstellen, ohne dass ein manueller Eingriff erforderlich ist. Das bedeutet, dass Sie weniger Zeit mit der Konfiguration von Servern verbringen und mehr Zeit für andere Aufgaben haben.

  • Plattformunabhängigkeit: Packer.io unterstützt eine Vielzahl von Plattformen, darunter Amazon EC2, Google Cloud, Microsoft Azure, VMware, Docker und viele mehr. Sie können also dasselbe Tool verwenden, unabhängig davon, wo Ihre Server laufen.

6.3. Wie funktioniert Packer.io?

Packer.io verwendet Konfigurationsdateien, die in JSON geschrieben sind. In diesen Dateien definieren Sie, welche Art von Maschinenbild Sie erstellen möchten, welche Software darauf installiert sein soll und wie das Bild konfiguriert werden soll.

Sobald Sie Ihre Konfigurationsdatei erstellt haben, verwenden Sie das Befehlszeilen-Interface von Packer.io, um das Maschinenbild zu erstellen. Packer.io führt dann eine Reihe von Schritten aus, die als "Provisioner" und "Post-Prozessoren" bezeichnet werden, um das Maschinenbild zu erstellen und zu konfigurieren.

6.4. Fazit

Packer.io ist ein leistungsfähiges Tool, das Ihnen hilft, konsistente und zuverlässige Serverumgebungen zu erstellen. Mit seiner Unterstützung für eine Vielzahl von Plattformen und seinem flexiblen Konfigurationssystem ist Packer.io ein unverzichtbares Tool für jeden, der mit Serverinfrastruktur arbeitet.

7. Skopeo

Arbeiten mit Remote-Images

Skopeo ist ein Befehlszeilen-Tool, das entwickelt wurde, um mit Container-Images und Image-Repositories zu interagieren. Es ermöglicht Benutzern, Images von Containerregistern herunterzuladen, Informationen über Images zu erhalten, Images zwischen Registern und lokalen Speichern zu verschieben und vieles mehr.

7.1. Hauptmerkmale von Skopeo

  • Breite Plattformunterstützung: Skopeo unterstützt eine Vielzahl von Containern und Image-Speicher, einschließlich Docker, OpenShift und mehr.

  • Inspektion von Images: Skopeo kann detaillierte Informationen über ein Image ohne dessen Herunterladen oder Ausführung liefern.

  • Kopieren und Synchronisieren von Images: Skopeo kann Images zwischen verschiedenen Registern und lokalen Speichern kopieren und synchronisieren.

7.2. Skopeo installieren und verwenden

Abhängig von deinem Betriebssystem, kann Skopeo wie folgt installiert werden:

Ubuntu und andere Linux-Distributionen: sudo apt-get install skopeo

Fedora: sudo dnf install skopeo

Nach der Installation kannst du Skopeo verwenden, um mit Container-Images zu arbeiten. Hier sind einige grundlegende Befehle und Beispiele:

7.2.1. Images inspizieren

Um Informationen über ein Image zu erhalten, verwenden Sie den inspect Befehl. Zum Beispiel:

$ skopeo inspect docker://docker.io/fedora

7.2.2. Images kopieren

Um ein Image von einem Register zu einem anderen zu kopieren, verwenden Sie den copy Befehl. Zum Beispiel:

$ skopeo copy docker://myregistry.com/myimage:latest docker://myotherregistry.com/myimage:latest

Bitte beachte, dass Skopeo verschiedene Authentifizierungsoptionen für den Zugriff auf private Register unterstützt. Weitere Informationen finden Sie in der Skopeo-Dokumentation.

Mit diesen grundlegenden Befehlen und Konzepten bist du in der Lage, effektiv mit Skopeo zu arbeiten und deine Arbeit mit Container-Images zu optimieren.

8. Terraform

terraform logo

Terraform ist ein Open-Source-Tool, entwickelt von HashiCorp, das dazu dient, Infrastruktur als Code (IaC) zu definieren und bereitzustellen. Es ermöglicht Benutzern, ihre gesamte Infrastruktur (einschließlich Netzwerk, Storage, Server usw.) in Code zu definieren, der in einer Versionskontrolle gespeichert werden kann. Dieser Code kann dann verwendet werden, um die Infrastruktur auf verschiedenen Plattformen zu erstellen und zu aktualisieren.

8.1. Welche Probleme werden damit gelöst?

Terraform löst eine Reihe von Problemen im Bereich Infrastrukturmanagement:

  1. Standardisierung und Wiederverwendbarkeit: Durch das Schreiben von Infrastruktur als Code können Teams ihre Setup-Prozesse standardisieren und Codeblöcke wiederverwenden, was zu einer effizienteren und konsistenteren Bereitstellung führt.

  2. Multi-Cloud-Deployments: Terraform unterstützt eine Vielzahl von Service-Providern und ermöglicht es Benutzern, ihre Infrastruktur über mehrere Cloud-Plattformen hinweg zu verwalten.

  3. Vereinfachte Änderungssteuerung: Mit Terraform können Änderungen an der Infrastruktur vor der Anwendung visualisiert und überprüft werden, was das Risiko von Ausfällen reduziert.

8.2. How to use it

Terraform verwendet eine eigene Domain Specific Language (DSL) namens HashiCorp Configuration Language (HCL), um Infrastruktur als Code zu definieren. Terraform-Prozesse werden im Allgemeinen in vier Schritten durchgeführt:

  • Schreiben Sie den Infrastrukturcode in HCL und speichern Sie ihn in .tf-Dateien.

  • Führen Sie terraform init aus, um das Terraform-Projekt zu initialisieren und die benötigten Provider-Plugins herunterzuladen.

  • Führen Sie terraform plan aus, um die Änderungen zu sehen, die auf der Infrastruktur vorgenommen werden.

  • Führen Sie terraform apply aus, um die Änderungen anzuwenden.

8.3. Beispielcodes

Ein einfacher Terraform-Code zum Erstellen einer AWS EC2-Instanz könnte folgendermaßen aussehen:

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "example" {
  ami           = "ami-0c94855ba95c574c8"
  instance_type = "t2.micro"

  tags = {
    Name = "example-instance"
  }
}

Nach dem Schreiben dieses Codes in einer .tf-Datei würden Sie terraform init, terraform plan und terraform apply in Ihrer Befehlszeile ausführen, um die Instanz zu erstellen.

8.4. Terraform Komponenten

8.4.1. Terraform Core

Terraform Core ist die primäre Komponente von Terraform und verantwortlich für das Lesen und Interpretieren der Terraform-Konfigurationen (in .tf Dateien), Erstellen und Verwalten des Zustands der Ressourcen, und Aufrufen von entsprechenden Anbietern, um diese Ressourcen zu erstellen und zu ändern.

8.4.2. Terraform CLI (Command Line Interface)

Terraform CLI ist das primäre Benutzerinterface für Terraform. Es bietet Befehle zum Verwalten und Interagieren mit Terraform-Konfigurationen, Zustand und Modulen.

8.4.3. Terraform Provider

Provider sind Plugins, die von Terraform genutzt werden, um mit verschiedenen Diensten zu interagieren. Sie definieren und bieten Ressourcen an, die in Terraform-Konfigurationen erstellt und verwaltet werden können. Einige Beispiele für Provider sind AWS, Google Cloud, Azure, usw.

8.4.4. Terraform Modules

Module sind selbstständige Pakete von Terraform-Konfigurationen, die als Einheiten wiederverwendet werden können. Sie können Ressourcen enthalten, Variablen definieren und Ausgaben produzieren.

8.4.5. Terraform State

Der Terraform-Zustand ist eine wichtige Komponente, die Terraform verwendet, um den aktuellen Zustand der in den Terraform-Konfigurationen definierten Ressourcen zu verfolgen.

8.4.6. Terraform Backends

Backends sind Komponenten, die zum Speichern des Terraform-Zustands und zur Durchführung von Operationen verwendet werden. Sie ermöglichen Funktionen wie Zustandsspeicherung, Zustandsverriegelung und Umgebungssteuerung.

8.5. Erstellung eines Terraform-Moduls

Zuerst, erstellen Sie ein neues Verzeichnis, das Ihr Modul enthalten wird. Zum Beispiel, my_module.

$ mkdir my_module

Als nächstes, erstellen Sie eine Terraform-Konfigurationsdatei innerhalb dieses Verzeichnisses. Nennen wir sie main.tf.

variable "image_id" {
  description = "Die ID des AMI"
}

variable "availability_zone_names" {
  description = "Eine Liste der Verfügbarkeitszonen"
  type        = list(string)
}

resource "aws_instance" "example" {
  ami           = var.image_id
  instance_type = "t2.micro"

  availability_zone = var.availability_zone_names[0]
}

output "instance_public_ip" {
  value = aws_instance.example.public_ip
}

8.5.1. Benutzen eines Terraform-Moduls

Jetzt können wir dieses Modul in unserer Haupt-Terraform-Konfiguration verwenden. Hier ist ein Beispiel, wie das aussehen könnte:

module "example_module" {
  source = "./my_module"

  image_id = "ami-abc123"
  availability_zone_names = ["us-west-2a", "us-west-2b"]
}

Jetzt können Sie terraform init und terraform apply ausführen, um das Modul in Aktion zu sehen.

8.6. Datei auf einen Server kopieren mit Terraform

Um eine Datei auf einen Server zu kopieren, kannst du den "file" oder den "template_file" Provider von Terraform verwenden. Du musst den Inhalt der Datei bereitstellen und die Datei in deiner Terraform-Konfiguration erstellen.

Hier ist ein Beispiel, wie du eine Datei in Terraform erstellst:

Beispiel: Datei mit dem Inhalt "Hallo, Welt!"
resource "null_resource" "example" {
  provisioner "file" {
    content     = "Hallo, Welt!"
    destination = "/pfad/zu/deiner/datei.txt"

    connection {
      type        = "ssh"
      user        = "username"
      password    = "password"
      host        = self.public_ip
    }
  }
}

In diesem Beispiel wird eine Datei mit dem Inhalt "Hallo, Welt!" an den angegebenen Pfad auf dem Server kopiert.

Arbeiten mit Passwörtern in Klartext ist ein Sicherheitsrisiko. Du solltest sichere Methoden zum Umgang mit Passwörtern verwenden, wie z.B. das Einlesen aus sicheren Speichern oder die Verwendung von SSH-Schlüsseln anstelle von Passwörtern.

Zusätzlich muss das Ziel-Server Terraform unterstützen und SSH-Zugriff ermöglichen. Du solltest sicherstellen, dass der Pfad zur Datei auf dem Zielserver existiert und schreibbar ist.

Falls du eine existierende Datei kopieren möchtest, kannst du die source Eigenschaft anstelle von content verwenden. Zum Beispiel:

Beispiel mit bereits vorhandener Datei
resource "null_resource" "example" {
  provisioner "file" {
    source      = "/pfad/zu/lokal/datei.txt"
    destination = "/pfad/zu/ziel/datei.txt"

    connection {
      type        = "ssh"
      user        = "username"
      password    = "password"
      host        = self.public_ip
    }
  }
}

Hierbei wird eine lokale Datei auf deinem Rechner an den angegebenen Pfad auf dem Server kopiert.

Ein weiteres Beispiel unter Verwendung von einem SSH-Key
resource "null_resource" "example" {
  provisioner "file" {
    content     = "Hallo, Welt!"
    destination = "/pfad/zu/deiner/datei.txt"

    connection {
      type        = "ssh"
      user        = "username"
      private_key = file("~/.ssh/id_rsa")
      host        = self.public_ip
    }
  }
}

Das Terraform-Verhalten kann sich abhängig von der spezifischen Serverkonfiguration und den verwendeten Terraform-Provisionern ändern. Dieses Beispiel könnte angepasst werden müssen, um in deiner spezifischen Umgebung zu funktionieren.

8.7. Vor- und Nachteile von Terraform

Wie jedes Tool hat auch Terraform seine Vor- und Nachteile:

Vorteile

  • Provider-übergreifend: Terraform unterstützt eine Vielzahl von Providern, sowohl Cloud als auch On-Premises.

  • Immutable Infrastructure: Terraform erstellt und verwaltet Ressourcen auf eine Weise, die Änderungen an der bestehenden Infrastruktur minimiert.

  • Einfach zu lernen: HCL ist eine recht einfache und lesbare Sprache.

Nachteile

  • Fehler können schwerwiegend sein: Ein Fehler in Ihrem Terraform-Code kann zu großen Problemen in Ihrer Infrastruktur führen.

  • Komplexität bei großen Setups: Während Terraform bei kleineren Projekten einfach zu verwenden ist, kann es bei großen und komplexen Setups schwierig sein, den Überblick zu behalten.

  • Fehlende Unterstützung für bestimmte Ressourcen: Während Terraform viele Provider unterstützt, gibt es immer noch Ressourcen und Dienste, die nicht unterstützt werden.

  • Keine Multiuser/Platform unterstützung: Per default werden die "state" - Files lokal abgelegt. Dadurch ist es nicht einfach so möglich, Änderungen von einem anderen Rechner oder anderem User durchzuführen. Hierzu müssen "backends" für die Provider definiert werden. Mögliche Backends sind Cloud-Speicher bei: Amazon, Google, Azure oder ein Cloud-Dienst von HashiCorp (Terraform). Eine weitere Alternative ist die Nutzung von GitLab als backend - mehr dazu im nächsten Kapitel.

8.8. Zusammenfassung

Abschließend ist Terraform ein leistungsstarkes Tool zur Verwaltung Ihrer Infrastruktur als Code. Mit seiner Fähigkeit, eine breite Palette von Anbietern zu unterstützen und den Infrastrukturprozess zu standardisieren, ist es ein unverzichtbares Tool in der modernen DevOps-Werkzeugkette. Es ist jedoch wichtig, sorgfältig mit Terraform umzugehen, um mögliche Fehler zu vermeiden, die Auswirkungen auf die Produktionsinfrastruktur haben könnten.

8.10. GitLab als Terraform Backend

8.10.1. With Workspace Support!? - untested

if [ -z $GIT_USERNAME ]
then
  echo "GIT_USERNAME not defined in environment"
  exit 1
fi
if [ -z $GIT_ACCESS_TOKEN ]
then
  echo "GIT_ACCESS_TOKEN not defined in environment"
  exit 1
fi

echo -n "terraform workspace (dev|test|prod)? "
read  WORKSPACE
echo ""
echo "WORKSPACE SELECTED: $WORKSPACE"

if [[ ! "$WORKSPACE" =~ ^(dev|test|prod)$ ]]; then
  echo "invalid workspace selected"
  exit 1
fi

PROJECT=project-name
PROJECT_ID=0000
STATE_ADDR="https://mygitlab/api/v4/projects/$PROJECT_ID/terraform/state/${WORKSPACE}_${PROJECT}"
terraform init \
    -backend-config="username=$GIT_USERNAME" \
    -backend-config="password=$GIT_ACCESS_TOKEN" \
    -backend-config="address=${STATE_ADDR}" \
    -backend-config="lock_address=${STATE_ADDR}/lock" \
    -backend-config="unlock_address=${STATE_ADDR}/lock" \

unset WORKSPACE

I run ./terraform_init.sh and create the workspace. To change workspace I delete .terraform/ and .terraform.lock.hcl and re run ./terraform_init.sh

9. ArgoCD

argo icon color

9.1. Welches Problem wird mit ArgoCD gelöst?

Anwendungsdefinitionen, Konfigurationen und Umgebungen sollten deklarativ und versioniert sein.

Die Anwendungsbereitstellung und das Lebenszyklusmanagement sollten automatisiert, überprüfbar und leicht verständlich sein.

9.2. Überblick

argocd gitops flow

9.3. Wie arbeitet ArgoCD?

  • Deklarativ - beschreibt Zielbild, nicht den Weg

  • Arbeitet mit Kubernetes und OpenShift

  • Kann folgende Quellen verarbeiten:

    • kubernetes manifests

    • Helm Charts

    • Kustomize resources

9.4. Ways to interact with ArgoCD

  • Web GUI

  • ArgoCD CLI

  • Kubernetes Manifest files

9.5. Installation von ArgoCD

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

Initiales Admin Password abfragen

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

9.7. Sync-Waves

tbd.

9.9. High Availability

High Availability installation is recommended for production use. This bundle includes the same components but tuned for high availability and resiliency.

  • ha/install.yaml - the same as install.yaml but with multiple replicas for supported components.

  • ha/namespace-install.yaml - the same as namespace-install.yaml but with multiple replicas for supported components.

9.10. Manage multible Cluster

9.11. Workflow Hardening

10. GitLab Pipelines

cicd pipeline infograph
  • vordefinierter Aktionen, die bei Events starten

  • Beispiel: bei Commit startet Testaktion

10.1. Gitlab Runner

  • Der Gitlab-CI-Server, auch Koordinator genannt, führt selbst keine Builds aus, sonder delegiert dies an sogenannte Runner.

  • Ein Runner ist ein Prozess, der auf einem beliebigen Rechner laufen kann, und den Koordinator pollt, um anstehende Jobs abzuholen und zu bearbeiten.

  • Der Runner kann direkt installiert sein oder als Container gestartet werden.

  • Gitlab Runner in Docker

10.2. Pipeline - Get started

  • GitLab CI/CD Configfile .gitlab-ci.yml

stages:
  - build
  - test

build-code-job:
  stage: build
  script:
    - ruby -v
    - rake

test-code-job1:
  stage: test
  script:
    - echo "If the files are built successfully, test:"
    - rake test1

10.3. Pipeline - Stages

stages

Die "Stages" - Liste gruppiert die Jobs und definiert die Reihenfolge der Ausführung.

stages:
  - build
  - test
  - deploy

10.4. Pipeline - Jobs

Jobs sind der fundamentale Bestandteil von Pipelines

  • in Jobs wird definiert, was ausgeführt werden soll

  • müssen mindestens das Element "script" enthalten

  • können beliebige Namen haben

  • sind in der Anzahl nicht begrenzt

  • max execution time = 60min per job

10.5. Pipeline - Job example

node-lint:
  image: $NODE_BASE_IMAGE
  stage: test
  script:
    - mkdir output
    - cd app
    - npm install --silent
    - npx eslint ./ --fix -f html -o ../output/lint-report.html
  artifacts:
    paths:
      - output/lint-report.html

11. Gitlab pipelines in advanced

Um eine GitLab-Pipeline zu erstellen, die mit mehreren Projekten arbeitet, können Sie die folgenden Schritte befolgen:

11.1. Projektübergreifende Pipelines definieren

Sie können in GitLab projektübergreifende Pipelines definieren, indem Sie die trigger-Anweisung in Ihrer .gitlab-ci.yml-Datei verwenden. Diese ermöglicht es einem Projekt, eine Pipeline in einem anderen Projekt auszulösen.

11.2. GitLab CI/CD-Konfigurationsdatei erstellen

In jedem beteiligten Projekt benötigen Sie eine .gitlab-ci.yml-Datei, die die Pipeline definiert. Diese Datei legt die Jobs und Stufen fest, die in der Pipeline ausgeführt werden sollen.

11.3. Trigger einrichten

In der .gitlab-ci.yml des auslösenden Projekts verwenden Sie die trigger-Anweisung, um die Pipeline eines anderen Projekts zu starten. Sie können beispielsweise angeben, welche spezifische Pipeline eines anderen Projekts gestartet werden soll und unter welchen Bedingungen dies geschehen soll.

11.4. Abhängigkeiten zwischen Projekten verwalten

Wenn Ihre Projekte voneinander abhängig sind, z. B. wenn ein Projekt ein Artefakt erstellt, das von einem anderen Projekt verwendet wird, müssen Sie diese Abhängigkeiten in Ihren Pipelines entsprechend verwalten. Dies kann durch das Übergeben von Artefakten zwischen Pipelines oder durch die Verwendung von gemeinsamen Speicherorten wie einem Artefakt-Repository erfolgen.

11.5. Zugriffsrechte konfigurieren

Stellen Sie sicher, dass die Projekte die erforderlichen Berechtigungen haben, um Pipelines in anderen Projekten auszulösen. Dies kann Zugriffstoken oder spezielle Berechtigungskonfigurationen umfassen.

11.6. Pipeline-Status überwachen und debuggen

Nachdem Sie die Pipelines eingerichtet haben, sollten Sie den Fortschritt überwachen und eventuelle Probleme debuggen. GitLab bietet eine visuelle Darstellung des Pipeline-Status, sowie detaillierte Logs für jeden Job.

Beachten Sie, dass die genaue Konfiguration von Ihrem spezifischen Anwendungsfall und der Struktur Ihrer Projekte abhängt. Die GitLab-Dokumentation bietet detaillierte Anleitungen und Beispiele, die Ihnen helfen können, Ihre Pipeline-Konfiguration zu optimieren.

11.7. Beispiel für projektübergreifende Pipelines

Hier ist ein einfaches Beispiel, wie man eine GitLab-CI-Pipeline konfigurieren kann, die mit mehreren Projekten arbeitet:

11.7.1. Projekt A: Hauptprojekt

Stellen Sie sich vor, Projekt A ist Ihr Hauptprojekt, das eine Pipeline in Projekt B auslöst.

gitlab-ci.yml in Projekt A
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
stages:
  - build
  - trigger

build_job:
  stage: build
  script:
    - echo "Building Project A..."

trigger_project_b:
  stage: trigger
  script:
    - echo "Triggering pipeline in Project B..."
  trigger:
    project: your-group/project-b
    branch: master

In diesem Beispiel gibt es zwei Stufen: build und trigger. Der build_job führt einen einfachen Befehl aus (z.B. den Build-Prozess), und trigger_project_b löst eine Pipeline im Projekt B aus.

11.7.2. Projekt B: Abhängiges Projekt

Projekt B könnte ein abhängiges Projekt sein, das durch Projekt A ausgelöst wird.

gitlab-ci.yml in Projekt B
1
2
3
4
5
6
7
stages:
  - test

test_job:
  stage: test
  script:
    - echo "Testing Project B..."

In Projekt B gibt es eine einfache Pipeline mit einer Teststufe. Diese Pipeline wird ausgelöst, sobald die trigger_project_b-Stufe in Projekt A erfolgreich abgeschlossen ist.

11.7.3. Hinweise

  • Ersetzen Sie your-group/project-b mit dem tatsächlichen Pfad Ihres Projekts B in GitLab.

  • Stellen Sie sicher, dass für das Projekt, das die Pipeline eines anderen Projekts auslöst, die entsprechenden Zugriffsrechte eingerichtet sind. Eventuell benötigen Sie ein [CI/CD-Token](https://docs.gitlab.com/ee/ci/triggers/#adding-a-new-trigger).

  • Dieses Beispiel ist grundlegend. Je nach Anforderungen Ihres Projekts können Sie komplexere Pipelines mit weiteren Stufen, Jobs und Bedingungen einrichten.

Diese Konfiguration ermöglicht eine einfache Interaktion zwischen zwei Projekten, wobei das eine Projekt (Projekt A) eine Aktion in einem anderen Projekt (Projekt B) auslöst.

12. Jenkins

Ein Überblick

jenkins logo

12.1. Einführung

Jenkins ist ein freies Open Source Automatisierungstool, das hauptsächlich mit Java entwickelt wurde. Es dient zur kontinuierlichen Integration und kontinuierlichen Bereitstellung (CI/CD) von Projekten.

12.2. Hauptmerkmale von Jenkins

Jenkins bietet zahlreiche Funktionen, die seine Verwendung für DevOps und CI/CD-Prozesse attraktiv machen:

  • Einfache Installation: Jenkins ist ein selbstständiges Java-Programm, das direkt aus dem Paket auf jedem System ausgeführt werden kann, auf dem Java installiert ist.

  • Plugin-Ökosystem: Es gibt Tausende von Jenkins-Plugins, die Integrationen mit fast jedem Tool im DevOps-Lebenszyklus ermöglichen.

  • Skalierbarkeit: Jenkins kann horizontal und vertikal skaliert werden, um den Anforderungen großer und komplexer Projekte gerecht zu werden.

  • Pipeline als Code: Jenkins ermöglicht es Benutzern, ihre CI/CD-Pipeline als Code zu definieren. Dies verbessert die Wartbarkeit und Versionskontrolle der Pipeline.

12.3. Jenkins-Architektur

Jenkins folgt einer Master-Slave-Architektur, um den Arbeitslast auszugleichen:

  • Master: Der Master koordiniert die Builds und verteilt die Aufgaben an die Slaves. Es speichert auch Konfigurationsdetails und stellt die Benutzeroberfläche und die API bereit.

  • Slaves: Die Slaves führen die Aufgaben aus, die ihnen vom Master zugewiesen wurden. Sie können auf verschiedenen Betriebssystemen laufen und unterschiedliche Hardwarekonfigurationen haben, je nach den Anforderungen der Builds.

12.4. Fazit

Jenkins ist ein äußerst vielseitiges und leistungsfähiges Tool für die Automatisierung von DevOps-Aufgaben. Sein großes Plugin-Ökosystem und seine Skalierbarkeit machen es zu einer hervorragenden Wahl für Teams jeder Größe.

13. Tekton

Eine Einführung, Anwendung und Analyse

tekton horizontal color

13.1. Einführung

Tekton ist ein leistungsstarkes und flexibles Open-Source-Framework für die Erstellung von Continuous Integration und Continuous Delivery (CI/CD) Systemen. Entwickelt, um Kubernetes nativ zu sein, stellt Tekton eine Reihe von Kubernetes Custom Resource Definitions (CRDs) zur Verfügung, um Pipelines zu erstellen, die passend zu den modernen softwareentwicklungspraktiken sind.

13.2. Welche Probleme werden damit gelöst?

Tekton löst eine Reihe von Herausforderungen im Bereich der Softwarelieferung:

  • Kompatibilität: Da Tekton auf Kubernetes basiert, kann es auf jeder Plattform eingesetzt werden, die Kubernetes unterstützt.

  • Anpassbarkeit: Tekton ist hochgradig anpassbar und kann sich leicht an verschiedene CI/CD-Workflows anpassen.

  • Wiederverwendbarkeit: Tekton-Aufgaben sind modular und wiederverwendbar, was bedeutet, dass Teams einmal erstellten Code in mehreren Pipelines verwenden können.

13.3. Wie benutzt man Tekton?

Die Verwendung von Tekton beinhaltet im Wesentlichen das Definieren und Ausführen von Tasks und Pipelines. Hier ist ein einfacher Ablauf zur Einrichtung eines Tekton-Workflows:

  1. Installieren Sie Tekton auf Ihrem Kubernetes-Cluster.

  2. Definieren Sie einen Task, der eine bestimmte Aufgabe ausführt.

  3. Definieren Sie eine Pipeline, die mehrere Tasks verbindet.

  4. Erstellen Sie einen PipelineRun, um die Pipeline auszuführen.

13.4. Beispielcodes

Hier ist ein einfacher Tekton Task, der ein Docker-Image erstellt:

apiVersion: tekton.dev/v1beta1
kind: Task
metadata:
  name: build-docker-image
spec:
  steps:
  - name: build-and-push
    image: docker:17.12.0-ce
    command: ["docker", "build", "-t", "my-image", "."]

13.5. Vor- und Nachteile

Wie jedes Tool hat auch Tekton seine Vor- und Nachteile:

13.5.1. Vorteile

  • Flexibilität: Tekton bietet eine hohe Flexibilität bei der Gestaltung von CI/CD-Workflows.

  • Wiederverwendbarkeit: Aufgaben in Tekton sind wiederverwendbar, was zur Effizienz der Pipelines beiträgt.

13.5.2. Nachteile

  • Komplexität: Tekton kann für Einsteiger komplex sein, besonders wenn man nicht mit Kubernetes vertraut ist.

  • Fehlende Benutzeroberfläche: Tekton selbst hat keine Benutzeroberfläche, obwohl es Drittanbieter-Optionen gibt.

Zusammenfassend lässt sich sagen, dass Tekton ein mächtiges Werkzeug für CI/CD-Pipelines ist, das sich durch seine Flexibilität und Wiederverwendbarkeit auszeichnet. Es hat jedoch eine steile Lernkurve und erfordert eine gute Kenntnis von Kubernetes.

14. Kubernetes

Kubernetes, ein weitverbreitetes System zur Orchestrierung von Containeranwendungen, besteht aus verschiedenen Komponenten, die gemeinsam eine robuste und skalierbare Plattform bilden. Hier sind die wichtigsten Komponenten:

14.1. Master-Knoten (Master Node)

Er steuert den Kubernetes-Cluster und besteht aus mehreren Teilen:

  • API-Server (kube-apiserver):
    Dient als Frontend für das Kubernetes-Steuerungsebenen-Netzwerk.

  • Etcd:
    Eine konsistente und hochverfügbare Schlüsselwert-Datenbank, die als Kubernetes’ Backing-Store für alle Clusterdaten genutzt wird.

  • Scheduler (kube-scheduler):
    Entscheidet, auf welchem Knoten neu erstellte Container platziert werden.

  • Controller-Manager (kube-controller-manager):
    Verwaltet die Controller, die den Zustand des Clusters überwachen und bei Bedarf Änderungen vornehmen.

14.2. Arbeitsknoten (Worker Nodes):

Diese Knoten führen die Containeranwendungen aus. Sie enthalten:

  • Kubelet: Eine Agent-Anwendung, die sicherstellt, dass die Container in einem Pod laufen.

  • Kube-Proxy: Ein Netzwerk-Proxy, der die Kubernetes-Netzwerkdienste auf dem Arbeitsknoten verwaltet.

  • Container-Runtime: Die Software, die für das Ausführen von Containern verantwortlich ist (z.B. Docker, containerd).

14.3. Pods

Die kleinste Einheit, die in Kubernetes erstellt und verwaltet wird. Ein Pod ist eine Gruppe von einem oder mehreren Containern, die Ressourcen wie Netzwerk und Speicherplatz teilen.

14.4. Deployment und ReplicaSets

Diese Komponenten ermöglichen es Ihnen, den gewünschten Zustand Ihrer Anwendung zu definieren und Kubernetes kümmert sich um dessen Einhaltung.

14.5. Services

Eine Abstraktion, die einen logischen Satz von Pods definiert und eine Policy, um auf sie zuzugreifen.

14.6. Namespaces

Erlauben die Unterteilung von Ressourcen in verschiedenen virtuellen Clustern im selben physischen Cluster.

14.7. ConfigMaps und Secrets

Für die Speicherung von Konfigurationsdaten und sensiblen Informationen, die von Pods genutzt werden können.

Diese Komponenten arbeiten zusammen, um eine hochverfügbare, skalierbare und flexible Umgebung für das Ausführen von containerisierten Anwendungen zu bieten. Kubernetes’ Architektur ermöglicht es, Anwendungen effizient und zuverlässig zu verwalten, zu skalieren und zu verteilen.

14.8. K8s - Ingress / Egress

In Kubernetes und im Bereich der Netzwerkkommunikation beziehen sich die Begriffe "Ingress" und "Egress" auf den Datenverkehr, der in das Netzwerk eintritt oder es verlässt. Hier sind die Hauptunterschiede:

14.8.1. Ingress:

  • Bedeutung:
    Ingress bezieht sich auf den eingehenden Netzwerkverkehr. In einem Kubernetes-Kontext bezeichnet es oft die Regeln und Mechanismen, die den Zugriff von außen auf Dienste innerhalb des Kubernetes-Clusters steuern.

  • Verwendung in Kubernetes:
    In Kubernetes ist ein Ingress eine API-Ressource, die den Zugriff auf HTTP- und HTTPS-Routen von außerhalb des Clusters zu den Services innerhalb des Clusters steuert. Es ermöglicht Ihnen, Zugriffsregeln zu definieren, Hostnamen oder URL-Pfade auf bestimmte Services abzubilden und sogar SSL/TLS-Zertifikate für diese Endpunkte zu handhaben.

  • Beispiel:
    Ein Ingress könnte konfiguriert werden, um Anfragen an meine-website.example.com an einen spezifischen Service in Ihrem Kubernetes-Cluster weiterzuleiten.

14.8.2. Egress:

  • Bedeutung:
    Egress bezieht sich auf den ausgehenden Netzwerkverkehr, also den Datenverkehr, der von Ihrem Netzwerk (z.B. einem Kubernetes-Cluster) zu einem externen Ziel fließt.

  • Verwendung in Kubernetes:
    In Kubernetes kontrollieren Egress-Regeln, wie der ausgehende Verkehr von den Pods in einem Cluster zu externen Diensten geleitet wird. Dies kann wichtig sein, um die Netzwerksicherheit zu gewährleisten oder um zu kontrollieren, wie Ressourcen außerhalb des Clusters genutzt werden.

  • Beispiel:
    Egress-Regeln könnten festlegen, dass bestimmte Pods Zugriff auf eine externe Datenbank oder eine API im Internet haben, während anderer Verkehr blockiert wird.

In der Praxis sind Ingress- und Egress-Kontrollen wesentliche Bestandteile des Netzwerkmanagements und der Sicherheit in Kubernetes, da sie detailliert steuern, wie der Datenverkehr in und aus dem Cluster fließt.

15. k9s

Kubernetes CLI To Manage Your Clusters

k9s

K9s is a terminal based UI to interact with your Kubernetes clusters. The aim of this project is to make it easier to navigate, observe and manage your deployed applications in the wild. K9s continually watches Kubernetes for changes and offers subsequent commands to interact with your observed resources.

15.1. Installation

K9s is available on Linux, macOS and Windows platforms.

Binaries for Linux, Windows and Mac are available as tarballs in the release page.

15.2. Features

15.2.1. Information At Your Finger Tips!

  • Tracks in real-time activities of resources running in your Kubernetes cluster.

15.2.2. Standard or CRD?

  • Handles both Kubernetes standard resources as well as custom resource definitions.

15.2.3. Cluster Metrics

  • Tracks real-time metrics associates with resources such as pods, containers and nodes.

15.2.4. Power Users Welcome!

  • Provides standard cluster management commands such as logs, scaling, port-forwards, restarts…

  • Define your own command shortcuts for quick navigation via command aliases and hotkeys.

  • Plugin support to extend K9s to create your very own cluster commands.

  • Powerful filtering mode to allow user to drill down and view workload related resources.

15.2.5. Error Zoom

  • Drill down directly to what’s wrong with your cluster’s resources.

15.2.6. Skinnable and Customizable

  • Define your very own look and feel via K9s skins.

  • Customize/Arrange which columns to display on a per resource basis.

15.2.7. Narrow or Wide?

  • Provides toggles to view minimal or full resource definitions

15.2.8. MultiResources Views

  • Provides for an overview of your cluster resources via Pulses and XRay views.

15.2.9. We’ve got your RBAC!

  • Supports for viewing RBAC rules such as cluster/roles and their associated bindings.

  • Reverse lookup to asserts what a user/group or ServiceAccount can do on your clusters.

15.2.10. Built-in Benchmarking

  • You can benchmark your HTTP services/pods directly from K9s to see how your application fare and adjust your resources request/limit accordingly.

15.2.11. Resource Graph Traversals

  • K9s provides for easy traversal of Kubernetes resources and their associated resources.

16. kURL

Open Source Kubernetes Installer

kurl logo@2x

"kURL - Kubernetes Installer" ist ein Tool, das zur Vereinfachung der Installation und Bereitstellung von Kubernetes-Clustern entwickelt wurde. Es bietet eine automatisierte Methode, um Kubernetes auf verschiedenen Plattformen einzurichten.

Die Verwendung von kURL erfolgt in mehreren Schritten:

16.1. Vorbereitung der Infrastruktur

Stellen Sie sicher, dass die Infrastruktur für Ihren Kubernetes-Cluster bereit ist. Dies umfasst das Einrichten von Servern oder virtuellen Maschinen, auf denen Kubernetes installiert werden soll.

16.2. Herunterladen von kURL

Laden Sie das kURL-Installationsprogramm herunter. Dieses Programm enthält die erforderlichen Skripte und Konfigurationsdateien, um die Kubernetes-Installation durchzuführen.

Zusätzlich besteht die Möglichkeit, nicht nur die Scripte, sondern auch alle benötigten Resourcen, in eine tar-File herunter zu laden. Damit ist dann auch eine einfache Installetion in einer Airgap-Umgebung möglich.

16.3. Konfiguration

Passen Sie die Konfigurationsdateien an Ihre spezifischen Anforderungen an. Dies umfasst die Festlegung von Netzwerkeinstellungen, Authentifizierungsoptionen, Speicheroptionen usw.

16.4. Installation

Führen Sie das kURL-Installationsprogramm aus und geben Sie die angepassten Konfigurationsdateien an. Das Installationsprogramm führt dann den Prozess der Kubernetes-Installation durch, einschließlich der Installation von Docker, der Einrichtung des Kubernetes-Master-Knotens und der Bereitstellung der Worker-Knoten.

16.5. Überprüfung

Nach Abschluss der Installation können Sie den Status des Kubernetes-Clusters überprüfen, um sicherzustellen, dass alles korrekt eingerichtet wurde. Dies umfasst die Überprüfung der Verfügbarkeit der Kubernetes-API und das Testen der Kommunikation zwischen den Clusterknoten.

16.6. Fazit

KURL ist ein flexibles Tool, das auf verschiedene Szenarien und Plattformen zugeschnitten werden kann. Es ermöglicht eine schnelle und effiziente Installation von Kubernetes-Clustern mit einem standardisierten Ansatz. Nicht zuletzt bietet es eine einfache Möglichkeit für Installationen in Airgap-Umgebungen.

17. Podman

17.1. Einleitung

Podman ist ein Tool zur Containerverwaltung, das von Red Hat entwickelt wurde und als Alternative zu Docker dient.

17.2. Vorteile gegenüber Docker

  • Daemon-los

  • Verbesserte Sicherheit durch Root-losen Betrieb

  • Aufgeteilte Befehle für verschiedene Aufgaben

17.3. Installation

17.3.1. macOS

  • Installation über Homebrew: brew install podman

  • VM-Initialisierung: podman machine init und podman machine start

17.3.2. Linux

  • Ubuntu: sudo apt-get -y install podman

  • Fedora: sudo dnf -y install podman

17.4. Häufig verwendete Befehle

  • podman pull: Image herunterladen

  • podman run: Befehl in neuem Container ausführen

  • podman ps: Container auflisten

  • podman exec: Prozess in laufendem Container ausführen

  • podman stop: Container stoppen

18. Trivy

Vulnerability Scanner

trivy logo

Im stetig wachsenden digitalen Zeitalter spielen Sicherheit und Datenschutz eine immer wichtigere Rolle. Ein kritischer Aspekt davon ist die Aufdeckung und Behebung von Sicherheitslücken in Software, auch als Vulnerabilities bekannt. Ein Tool, das sich dabei als besonders nützlich erweist, ist der Trivy-Scanner.

18.1. Was ist Trivy?

Trivy, entwickelt von Aqua Security, ist ein umfassender und einfach zu bedienender Vulnerability-Scanner für Container und andere Artefakte. Es wurde mit dem Fokus auf Komfort und Effizienz entwickelt, ohne dabei auf Präzision und Zuverlässigkeit zu verzichten.

Trivy ist leicht zu installieren und kann sowohl auf der Kommandozeile als auch in der CI/CD-Pipeline genutzt werden. Es hat eine umfangreiche Abdeckung von Betriebssystemen und Sprachpaketen und liefert genaue Ergebnisse, indem es sowohl Betriebssystem- als auch Sprachspezifische Schwachstellen aufdeckt.

trivy

18.2. Warum Trivy?

Das Besondere an Trivy ist seine einfache Handhabung. Es erfordert keine aufwendige Konfiguration und ist daher besonders benutzerfreundlich. Die Benutzer müssen nur den Namen des Containers oder des Repositories angeben, und Trivy kümmert sich um den Rest.

Darüber hinaus besticht Trivy durch seine geringe False-Positive-Rate. Dies ist von entscheidender Bedeutung, da ein übermäßig hoher False-Positive-Rate die Effektivität eines Vulnerability-Scanners erheblich einschränken kann. Durch die Verwendung eines umfassenden Schwachstellendatensatzes und einer genauen Matching-Logik kann Trivy eine genaue und effiziente Analyse bieten.

18.3. Codebeispiele

Hier sind ein paar Beispiele, wie Sie den Trivy-Scanner in Ihren Code integrieren können.

18.3.1. Scannen eines Docker-Images

Das einfachste Beispiel ist das Scannen eines Docker-Images. Hier ist ein Befehl, um ein Image zu scannen:

trivy image [Optionen] ImageName

Beispiel:

trivy image python:3.7-alpine

18.3.2. Scannen eines Dateisystems

Sie können auch ein bestimmtes Dateisystem mit Trivy scannen:

trivy fs /pfad/zum/dateisystem

18.3.3. Integration in eine CI/CD Pipeline

Trivy kann auch in CI/CD-Pipelines integriert werden. Hier ist ein einfaches Beispiel für die Integration in eine GitHub Actions Pipeline:

name: CI

on:
  push:
    branches: [ master ]

jobs:
  trivy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'python:3.7-alpine'
          format: 'template'
          template: '@/contrib/sarif.tpl'
          output: 'trivy-results.sarif'

      - name: Upload Trivy scan results to GitHub Security tab
        uses: github/codeql-action/upload-sarif@v1
        with:
          sarif_file: 'trivy-results.sarif'

18.4. Zusammenfassung

Zusammenfassend lässt sich sagen, dass Trivy eine hervorragende Wahl für Entwickler und Sicherheitsteams ist, die einen gründlichen und zuverlässigen Vulnerability-Scanner benötigen. Mit seiner einfachen Handhabung, genauen Ergebnissen und weitreichenden Abdeckung ist Trivy ein unverzichtbares Tool in der modernen Softwareentwicklung.

Es ist klar, dass die Bedeutung von Vulnerability Scanning in der heutigen Welt nicht genug betont werden kann. Und mit Tools wie Trivy wird diese Aufgabe um einiges einfacher und effektiver. Mit kontinuierlichen Updates und Verbesserungen bleibt Trivy auch weiterhin ein Vorreiter auf dem Gebiet der Sicherheit im Bereich Softwareentwicklung.

Indem wir die Risiken erkennen und aktiv angehen, können wir sicherstellen, dass unsere digitalen Lösungen sicher bleiben und weiterhin Vertrauen und Zuverlässigkeit bieten. Dabei ist Trivy ein wichtiger Verbündeter.

19. Asciidoctor

asciidoctor logo

AsciiDoc ist eine vereinfachte Auszeichnungssprache, die dazu dient, Texte in verschiedenen Dokumentenformaten zu veröffentlichen.

AsciiDoc hat den Vorteil, leicht erlernbar zu sein und auch unverarbeitet (als Quelltext) gut lesbar zu sein.

19.1. Welches Problem wird damit gelöst?

  • docx, pdf nicht in GIT / Versionskontrolle verwaltbar

  • Erstellung von Dokument in verschiedenen Formaten ist aufwendig

  • Ergebnis nicht immer korrekt reproduzierbar

  • Anpassungen benötigen oft spezielle Software (Office, Visio, usw.)

19.2. Wie löst Aciidoc diese Probleme?

  • Asciidoc Dokumente sind in Rohform lesbar

  • Doc as code

  • Presentation as code

  • Keine spezielle Software notwendig

  • Ausgabe in verschiedene Formate möglich

  • Formatierung über Templates

19.3. Asciidoc Code - Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
= Asciidoc Beispiel
:Author: Thomas Siwczak
:Email: thomas.siwczak@de.experis.com
:Date: 11.05.2022
:Revision: 1.2.3
:data-uri: true
:toc: // Inhaltsverzeichnis

== Erstes Kapitel

Hier könnte hier Werbung stehen. Allerdings wird das
nicht billig! Zeilenumbrüche im Text werden nicht übernommen.

Zweiter Absatz - wird durch eine Leerzeile getrennt.
Danach folgt ein Bild.

.Schönes Bild
image::../images/nice-pic.jpg[width=50%,align="center"]

== Zweites Kapitel

Noch mehr nützliche Informationen, die mit Geld
nicht zu bezahlen sind.

19.4. Ergebnis als Html Output

example 1

19.5. Funktionsübersicht

asciidoc.drawio

19.6. Headlines

== Level 1 / Kapitel

Level 1 / Kapitel

=== Level 2

Level 2

==== Level 3
Level 3
===== Level 4
Level 4

19.7. Paragraphs

1
2
3
4
5
Ein erster Absatz mit nicht ganz so viel Text.
*Auch hier könnte ihre Werbung stehen!*

Der zweite Absatz wird durch eine Leerzeile
getrennt und dadurch automatisch ein neue Absatz erzeugt.

Ein erster Absatz mit nicht ganz so viel Text. Auch hier könnte ihre Werbung stehen!

Der zweite Absatz wird durch eine Leerzeile getrennt und dadurch automatisch ein neue Absatz erzeugt.

19.8. Formatierung

*Fett*

Fett

_Kursiv_

Kursiv

+Monospace+

Monospace

Einen Zeilenumbruch +
erzwingen

Einen Zeilenumbruch
erzwingen

19.9. Images

1
2
3
image::images/nice-pic.jpg[]
// oder mit optionalen Attributen
image::images/nice-pic.jpg[width=50%, algin="center"]
nice pic

19.10. Listen

1
2
3
4
5
6
7
// unordered list
* First
** sub first
** sub secound
*** Sub Sub
* Second
* Thirt
1
2
3
4
5
6
7
// ordered list
. First
.. sub first
.. sub secound
... Sub Sub
. Second
. Thirt

19.11. Listen Ergebnis

Unordered list
  • First

    • sub first

    • sub secound

      • Sub Sub

  • Second

  • Thirt

Ordered list
  1. First

    1. sub first

    2. sub secound

      1. Sub Sub

  2. Second

  3. Thirt

19.12. Tabellen

A table with a title
|===
|Column 1, header row |Column 2, header row
|Cell in column 1, row 2
|Cell in column 2, row 2
|===
Column 1, header row Column 2, header row

Cell in column 1, row 2

Cell in column 2, row 2

19.13. Tabellen - Best Practice

[%header,format=csv]
|===
Artist,Track,Genre
Baauer,Harlem Shake,Hip Hop
The Lumineers,Ho Hey,Folk Rock
|===
Artist Track Genre

Baauer

Harlem Shake

Hip Hop

The Lumineers

Ho Hey

Folk Rock

19.14. Sourcecode

[source, java, linenums]
----
class Simple{
    public static void main(String args[]){
     System.out.println("Hello Java");
    }
}
----
1
2
3
4
5
class Simple{
    public static void main(String args[]){
        System.out.println("Hello Java");
    }
}

19.15. Inhaltsverzeichnis

Im Dokumenten-Header :toc: angeben, damit wird automatisch ein Inhaltsverzeichnis erstellt.

= Dokument mit Inhaltsverzeichnis
Thomas Siwczak <thomas.siwczak@de.experis.com>

:toc:  // normal

:toc: left  // In HTML Ausgabe Inhaltsverzeichnis links

:toc: macro  // Damit kann das Verzeichnis frei platziert werden

// some Text

toc::[]  // Platzierung des Verzeichnis

19.16. Diagram Source

diag md30

19.17. Diagram - Output

diag msd30
Abbildung 1: MSD30

19.18. Output Format

  • html

  • pdf

  • xml / docbook

  • reveal.js / Slides

  • mit Pandoc weitere Formate:

    • docx

    • odt

    • uvm.

19.19. Best Practice

folgt in Kürze …​

  • Captions

  • includes

  • Tabellen

  • Diagrams

  • Templates

  • uvm.

19.20. Captions

19.21. Best Practice - Includes

Mittels includes lassen sich komplette Source Code Dateien oder Config Files extern in die Dokumentation einbinden (z.B. yaml files) Dadurch wird bei der Aktualisierung des Sourcecode automatisch auch immer die Dokumentation mit aktualisiert.

(adoc, Code, meta-data, uws.)

19.22. Best Practice - Diagrams

  • ditaa

  • plantuml

  • draw.io ?

19.23. Best Practice - Tabellen mit csv

19.24. Best Practice - Templates

19.25. Pandoc

19.26. Dokumente generieren

Einfaches Beispiel
asciidoctor handbuch.adoc
Beispiel mit Diagram-Addon
asciidoctor handbuch.adoc -r asciidoctor-diagram
Generierung von PDF
asciidoctor-pdf handbuch.adoc
// oder
asciidoctor-pdf handbuch.adoc -r asciidoctor-diagram  -o output/handbuch.pdf

19.27. Dokumente generieren mit Docker

// asciidoctor
docker run --rm -v $(pwd):/documents/ asciidoctor/docker-asciidoctor asciidoctor index.adoc

// asciidoctor-pdf
docker run --rm -v $(pwd):/documents/ asciidoctor/docker-asciidoctor asciidoctor-pdf index.adoc

// asciidoctor mit diagram
docker run --rm -v $(pwd):/documents/ asciidoctor/docker-asciidoctor asciidoctor -r asciidoctor-diagram index.adoc
Aktuelles Verzeichnis als Volume angeben:
-v $(pwd):/documents/

19.28. Dokumente generieren mit Podman

podman run --rm -v $(pwd):/documents/ docker.io/asciidoctor/docker-asciidoctor asciidoctor-pdf index.adoc
Imagename = docker.io/asciidoctor/docker-asciidoctor

20. Hugo

hugo logo wide

20.1. Einführung

Hugo ist ein statischer Site-Generator, der in Go geschrieben wurde. Er ist bekannt für seine Geschwindigkeit und Flexibilität. Im Gegensatz zu dynamischen Web-Content-Management-Systemen, die Serverressourcen benötigen, generiert Hugo die gesamte Website in HTML, CSS und JavaScript vor dem Hochladen auf den Server.

20.2. Hauptmerkmale von Hugo

Die Hauptmerkmale von Hugo beinhalten:

  • Schnelligkeit: Hugo ist bekannt als der schnellste Website-Generator auf dem Markt. Er kann Tausende von Seiten in Sekundenbruchteilen generieren.

  • Go Templates: Hugo verwendet Go’s eingebaute Template-Bibliothek für die Erstellung von Website-Templates.

  • Markdown Unterstützung: Hugo unterstützt Markdown für Inhalte, was es einfach macht, Inhalte zu erstellen und zu formatieren.

  • Anpassungsfähigkeit: Hugo kann einfach angepasst werden, um eine Vielzahl von Website-Typen zu erstellen, einschließlich Blogs, Dokumentation, Portfolio-Sites und mehr.

20.3. Hugo’s Architektur

Hugo verwendet eine einfache Verzeichnisstruktur, die es dem Benutzer ermöglicht, die Struktur und das Design seiner Website intuitiv zu verstehen. Die Hauptkomponenten sind:

  • Content-Verzeichnis: Hier speichert der Benutzer seine Inhaltsdateien. Jede Datei wird zu einer Seite auf der Website.

  • Layout-Verzeichnis: Hier werden die HTML-Templates gespeichert, die definieren, wie die Website aussieht.

  • Static-Verzeichnis: Hier werden alle statischen Ressourcen wie Bilder, CSS- und JavaScript-Dateien gespeichert.

20.4. Fazit

Hugo ist ein leistungsfähiges Tool für die Erstellung von Websites. Seine Geschwindigkeit, Flexibilität und einfache Anpassung machen es zu einer ausgezeichneten Wahl für Entwickler aller Erfahrungsstufen.

21. Git

git logo

21.1. Was ist Git?

Git ist eine Sammlung von Dienstprogrammen in der Kommandozeile, die Änderungen in Dateien verfolgen und aufzeichnen (meistens Quellcode, aber du kannst alle möglichen Dateien wie Textdateien und sogar Bild-Dateien "tracken".

Durch diese Funktionalität kannst du alte Versionen deines Projekts wiederherstellen, miteinander vergleichen, analysieren, Änderungen zusammenführen (mergen) und vieles mehr.

21.2. Die Vorteile der Versionsverwaltung mit Git

  • verteiltes System zur Codeverwaltung

  • Snapshots des aktuellen Zustands eines Codes

  • Effiziente und intelligente Zusammenarbeit im Team

  • Es erzeugt Zweige, die mehrere Arbeitsströme von verschiedenen Entwicklern, unabhängig voneinander, festhalten. Diese Zweige können zu einer einzigen Code-Datei zusammengeführt werden.

  • Änderungen am Code sind nachvollziehbar, wer ihn geändert hat, wann er geändert wurde und welche Versionen es vorher gab.

  • Es ist betriebssystem- und sprachunabhängig. Jeder Entwickler kann von jedem System und mit jeder Sprache an Git arbeiten.

  • Git ist natürlich nicht die einzige Versionsverwaltung. Andere Versionsverwaltungssysteme sind CVS, Bazaar und SNV.

21.3. Funktionsweise

21.4. Repo Arten

Normales Git Repo

Repository (History) und Arbeitsverzeichnis für Änderungen

Bare / mirror

nur Repository und kein Arbeitsverzeichnis

zur zentralen Ablage / pull & push möglich

21.5. Häufig genutzte Commands

Es folgt eine Auswahl der häufig genutzten Befehle

init, clone, config, status, log, add, commit, fetch, pull, push, stash, branch, remote

21.6. git init / git clone

Dieser Befehl (git init) initialisiert ein neues lokales Git Repository. Der Repo-Name wird direkt nach dem Befehl hinzugefügt.

git init <myrepo>

Mit diesem Befehl (git clone) können wir den Quellcode aus einem entfernten Repository auf einen lokalen Rechner herunterladen. Er erstellt eine Kopie dieses Repos auf dem lokalen Rechner.

git clone <URL>
Es ist auch möglich lokale Repos aus dem Dateisystem zu clonen, muss nicht zwingend von einem Server erfolgen.

21.7. git config (email, name)

Dieser Befehl erlaubt es dir, git mitzuteilen, wer du bist. Du kannst deinen Namen und deine E-Mail hinzufügen.

git config --global user.name “[firstname lastname]”

set a name that is identifiable for credit when review version history

git config --global user.email “[valid-email]”

set an email address that will be associated with each history marker

git config --global color.ui auto

set automatic command line coloring for Git for easy reviewing

21.8. git status

Dieser Befehl zeigt den Status eines Branches an. Die Verwendung dieses Befehls sagt uns, ob es ungetrackte, staged oder unstaged Dateien gibt. Es lässt uns wissen, ob es Dateien zum Committen, Pushen oder Pullen gibt und ob ein Branch aktuell ist.

git status
git status
Figure 1. Beispiel - git status

21.9. git diff

diff of what is changed but not staged

git diff

diff of what is staged but not yet committed

git diff --staged
git diff
Figure 2. Beispiel - git diff

21.10. git log

Listet all Commits für den aktuellen Branch auf.

git log

um die Anzahl beschränken kann man einen Parameter angeben, z.B. für 3 "-3" und für einen einzeilige Anzeige wird der Parameter "--pretty=oneline" benutzt.

git log -10 --pretty=oneline

Um einen bestimmt Datei zu verfolgen:

git log --follow [file]

21.11. git add

Hiermit wird eine Datei bereitgestellt, damit sie an das Repository übergeben werden kann. Sie können auf drei Arten bereitstellen.

  • git add * fügt alle Dateien, Ordner und Unterordner in einem Verzeichnis hinzu, mit Ausnahme von Dateien, die mit einem Punkt wie .gitignore beginnen.

  • git add <filename> fügt nur die Datei hinzu, die mit dem Dateinamen angegeben wurde.

  • git add . fügt alle Dateien, Ordner und Unterordner in einem Verzeichnis hinzu, einschließlich der Dateien, die mit einem Punkt wie .gitignore beginnen.

    git add <filename>
    // for example
    git add hallo.txt

21.12. git commit

Dieser Befehl speichert Snapshots der Arbeitsversion eines Projekts. Er tut dies, indem er alle Dateien in das Repository überträgt. Du kannst commit nur verwenden, nachdem du die Dateien mit git add ins Repository gestellt hast.

Commits werden normalerweise mit einer Commit-Nachricht hinzugefügt.

git commit -m “[descriptive message]”

Alternativ kann auch der Parameter -m weg gelassen werden, dann öffnet sich im Anschluss der Standart Editor, wo dann die Commit Message bearbeitet / eingegeben werden muss.

Die Commit-Message sollte einer gewissen Struktur entsprechen, mehr dazu im Abschnitt: Commit Messages

21.13. git show (new)

Zeigt die letzt commit meaasge an oder eine bestimmte, wenn man einen commit hash angibt

git show -s
git show -s b907a23e9cdf08f04c009863140c3460bb0ff748
git show
Figure 3. Beispiel - git show

21.14. git fetch / git pull

fetch - fetch down all the branches from that Git remote

git fetch

git pull holt und lädt Inhalte von einem entfernten Repo herunter und aktualisiert das lokale Repo mit den heruntergeladenen Inhalten.

git pull

21.15. git push

Dieser Befehl pusht übertragene Änderungen aus einem lokalen Branch in ein anderes Repository.

git push [alias] [branch]
// for example
git push origin dev

21.16. git - stages

git stages local

21.17. git stash (list, show, drop, pop / apply)

Stash local changes

git stash

List stashed changes

git stash list

Show stashed changes

git stash show

Remove stashed changes

git stash drop [<stash>]

Create branch from stashed changes and delete(!) stash

git stash branch <branchname> [stash>]

Remove single stashed state from stash list and apply it on current working tree

git stash pop [<stash>]

Apply stash to current working tree

git stash apply [<apply>]

Remove all stash entries

git stash clear

Saving temp work without stash

// hack hack hack
git switch -c my_wip
git commit -a -m "WIP"
git switch master
edit emergency fix
git commit -a -m "Fix in a hurry"
git switch my_wip
git reset --soft HEAD^
// continue hacking

Saving work with stashing

// hack hack hack
git stash
edit emergency fix
git commit -a -m "Fix in a hurry"
git stash pop
// continue hacking

21.18. branches

Show local branches

git branch

Show all branches

git branch -a

Create new branch

git branch <my_branch>
git checkout <my_branch>

Alternativer Shortcut

git checkout -b <my_branch>

Unterschiede zwischen Branches ermitteln / anzeiegn

git diff branchB...branchA

21.19. git remote

Origin - default remote

show details of remote settings

git remote show origin

get the remote repo-url

git remote get-url origin

set a new url for remote repo

git remote set-url origin

Weitere Remotes sind mittels

git remote add <name> <url>

definierbar.

21.20. Git stages

21.21. Commit Messages

Commit Messages sollten mit einer gewissen Stuktur erstellt werden: ADD:, CHG:, DEL: der Message voranstellen, Kurzbeschreibung in einer Zeile. Ausführliche Beschreibung der Änderung (Was, in welche[r|n] Datei[en], ggfs. Change-Nr, in weiteren Zeilen

21.22. .gitignore file

21.23. Best Practice

Does Don’t does

Name & Email setzen

git push --force

gute commit messages

bad code pushen

Branches nutzen

in master / main pushen

max 1 Funktion in commit

viele Changes in 1 Commit packen

21.24. Git-Submodule

Ein Git-Submodul ermöglicht es Ihnen, ein Git-Repository als Unterverzeichnis in einem anderen Git-Repository zu haben. Dies ist nützlich, wenn Sie Code wiederverwenden möchten, der in einem anderen Repository gepflegt wird. Hier ist ein einfacher Leitfaden, um ein Git-Submodul hinzuzufügen und es zu nutzen:

21.24.1. Git-Submodul hinzufügen

Um ein Submodul hinzuzufügen, verwenden Sie den git submodule add Befehl, gefolgt von der URL des Repositories, das Sie als Submodul hinzufügen möchten. Zum Beispiel:

1
git submodule add https://github.com/beispiel/repo.git

Dieser Befehl erzeugt ein neues Unterverzeichnis in Ihrem aktuellen Repository, klont das andere Repository hinein und setzt es auf den aktuellen Commit fest.

21.24.2. Git-Submodul aktualisieren

Nachdem das Submodul hinzugefügt wurde, ist es auf den Commit festgesetzt, der zu der Zeit aktuell war. Wenn Sie das Submodul auf den neuesten Stand bringen möchten, müssen Sie das Unterverzeichnis des Submoduls wechseln und git pull ausführen.

1
2
cd repo
git pull origin main

21.24.3. Git-Submodul entfernen

Das Entfernen eines Submoduls erfordert ein paar Schritte mehr:

  • Entfernen Sie das Submodul aus der .gitmodules Datei.

  • Entfernen Sie das Submodul aus der .git/config Datei.

  • Führen Sie git rm --cached path_to_submodule aus (keinen abschließenden Schrägstrich).

  • Führen Sie rm -rf .git/modules/path_to_submodule aus.

  • Commit und löschen Sie das nun unverfolgte Submodul-Verzeichnis.

1
2
3
git rm --cached repo
rm -rf .git/modules/repo
rm -rf repo

Bitte ersetzen Sie repo durch den Namen Ihres Submoduls.

21.25. Nützliche Commandos / Befehle

Ermittelt die höchste Version / höchsten git tag
1
2
3
4
5
// tags aus remote repos abrufen
git fetch --tags

// tags auflisten | sortieren | letzten anzeigen
git tag | sort -V | tail -n 1

22. Semantic Versioning

22.1. Zusammenfassung

Auf Grundlage einer Versionsnummer von MAJOR.MINOR.PATCH werden die einzelnen Elemente folgendermaßen erhöht:

  1. MAJOR wird erhöht, wenn API-inkompatible Änderungen veröffentlicht werden,

  2. MINOR wird erhöht, wenn neue Funktionalitäten, die kompatibel zur bisherigen API sind, veröffentlicht werden, und

  3. PATCH wird erhöht, wenn die Änderungen ausschließlich API-kompatible Bugfixes umfassen.

Außerdem sind Bezeichner für Vorveröffentlichungen und Build-Metadaten als Erweiterungen zum MAJOR.MINOR.PATCH-Format verfügbar.

23. RKE2 - Rancher

RKE2 steht für "Rancher Kubernetes Engine 2", und es handelt sich dabei um eine Kubernetes-Distribution, die von Rancher Labs entwickelt wurde. Kubernetes ist ein Open-Source-Container-Orchestrierungs-Framework, das dazu dient, Container-Anwendungen in skalierbaren, hochverfügbaren Clustern zu verwalten. RKE2 ist eine spezielle Implementierung von Kubernetes, die einige besondere Merkmale und Vorteile bietet:

  1. Einfache Bereitstellung: RKE2 wurde entwickelt, um die Bereitstellung von Kubernetes-Clustern zu vereinfachen. Es bietet ein benutzerfreundliches Installations- und Konfigurationsverfahren, das auch für Einsteiger zugänglich ist.

  2. Sicherheit: RKE2 setzt auf Sicherheit und konzentriert sich auf die Minimierung von Angriffsflächen. Es verwendet standardmäßig den Containerd-Container-Manager anstelle von Docker und bietet Funktionen wie SELinux und AppArmor zur weiteren Verbesserung der Sicherheit.

  3. High Availability: RKE2 unterstützt die Einrichtung von hochverfügbaren Kubernetes-Clustern. Dies bedeutet, dass Ihr Cluster weiterhin funktionieren kann, selbst wenn einzelne Komponenten oder Knoten ausfallen.

  4. Automatisierung: RKE2 enthält Funktionen zur Automatisierung von Aufgaben wie Updates und Upgrades, was die Wartung und Verwaltung Ihres Kubernetes-Clusters erleichtert.

  5. Kubernetes-Kompatibilität: RKE2 bleibt eng mit der Kubernetes-Community und dem Kubernetes-Ökosystem verbunden und ist daher mit vielen Kubernetes-Tools und -Ressourcen kompatibel.

  6. Modularität: RKE2 verwendet eine modulare Architektur, die es Ihnen ermöglicht, Komponenten und Erweiterungen nach Bedarf hinzuzufügen oder zu entfernen.

  7. Unterstützung für verschiedene Plattformen: RKE2 kann auf verschiedenen Betriebssystemen und Infrastrukturplattformen, einschließlich Bare-Metal-Servern, virtuellen Maschinen und Cloud-Diensten, ausgeführt werden.

Die Vorteile von RKE2 machen es zu einer attraktiven Option für Unternehmen und Entwickler, die Kubernetes in ihren Anwendungen und Diensten verwenden möchten, da es die Einrichtung, Verwaltung und Sicherheit von Kubernetes-Clustern erleichtert. Beachten Sie jedoch, dass sich die Technologie und Features von RKE2 im Laufe der Zeit weiterentwickeln können, sodass es ratsam ist, die neuesten Informationen und Dokumentationen zu überprüfen, um die aktuellen Funktionen und Best Practices zu verstehen.

23.1. Install

23.1.1. ARM64

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
mkdir /root/rke2-artifacts && cd /root/rke2-artifacts
wget http://bit.ly/3GQOxhd rke2-images.linux-arm64.tar.gz
wget https://github.com/rancher/rke2/releases/download/v1.27.3+rke2r1/rke2.linux-arm64.tar.gz
wget https://github.com/rancher/rke2/releases/download/v1.27.3+rke2r1/sha256sum-arm64.txt
curl -sfL https://get.rke2.io --output install.sh

INSTALL_RKE2_TYPE=agent INSTALL_RKE2_ARTIFACT_PATH=/root/rke2-artifacts sh install.sh

systemctl enable rke2-server
systemctl start rke2-server
Kubectl
1
2
3
curl -LO https://dl.k8s.io/release/v1.28.4/bin/linux/arm64/kubectl
install kubectl /usr/local/bin
rm kubectl -f
k9s
1
2
3
4
5
6
7
curl -LO https://github.com/derailed/k9s/releases/download/v0.29.1/k9s_Linux_arm64.tar.gz

tar xvzf k9s_Linux_arm64.tar.gz k9s (1)

install k9s /usr/local/bin

rm -f k9s k9s_Linux_arm64.tar.gz (2)
1 Unpack only k9s binary from archive
2 Cleanup

23.2. Create Aliase

1
2
3
4
alias kcn='kubectl config set-context --current --namespace'
alias k='kubectl'
alias kpo='kubectl get po -A'
alias kepo='kubectl get po -A | grep -Ev "Running|Completed"'

24. HAProxy

Vor- und Nachteile, Installation & Konfiguration

HAProxy ist ein beliebter Load Balancer und Proxy-Server, der sich besonders durch seine Leistung und Zuverlässigkeit auszeichnet. Im Vergleich zu anderen Load Balancern bietet HAProxy sowohl Vorteile als auch Nachteile. Hier ist ein Überblick:

24.1. Vorteile von HAProxy

  1. Hohe Leistung und Zuverlässigkeit: HAProxy ist bekannt für seine hohe Durchsatzkapazität und geringe Latenz, was es ideal für hochverfügbare Umgebungen macht.

  2. Flexibilität in der Konfiguration: HAProxy bietet eine sehr detaillierte und flexible Konfiguration, die es ermöglicht, Verkehr sehr präzise zu steuern und zu manipulieren.

  3. Unterstützung für HTTP und TCP: Es kann sowohl als HTTP-Load-Balancer als auch als TCP/UDP-Load-Balancer verwendet werden, was es vielseitig einsetzbar macht.

  4. Gesundheitsprüfungen und Failover: HAProxy bietet fortschrittliche Gesundheitsprüfungen und Failover-Mechanismen, um die Verfügbarkeit der Dienste zu gewährleisten.

  5. Open Source und Gemeinschaftsunterstützung: Als Open-Source-Tool hat es eine starke Community, die ständig zur Weiterentwicklung des Tools beiträgt.

  6. SSL/TLS-Unterstützung: Es unterstützt SSL/TLS-Terminierung, was die Sicherheit verbessert.

24.2. Nachteile von HAProxy

  1. Komplexität in der Konfiguration: Die detaillierte Konfiguration kann für neue Benutzer überwältigend sein und erfordert ein gewisses Maß an technischem Verständnis.

  2. Fehlende GUI: Im Gegensatz zu einigen anderen Lösungen bietet HAProxy keine grafische Benutzeroberfläche, was die Konfiguration und das Management erschwert.

  3. Eingeschränkter Support für Websockets: Obwohl HAProxy Websockets unterstützt, kann es im Vergleich zu spezialisierten Lösungen Limitierungen geben.

  4. Keine native Cloud-Integration: Im Gegensatz zu Cloud-nativen Lösungen wie AWS Elastic Load Balancing oder Azure Load Balancer bietet HAProxy keine direkte Integration mit Cloud-Diensten.

24.3. Vergleich mit Anderen Load Balancern

  • Nginx: Nginx ist ebenfalls ein sehr beliebter Load Balancer und Webserver. Im Vergleich zu HAProxy bietet Nginx eine einfachere Konfiguration und eine bessere Integration in Webserver-Funktionalitäten, ist aber in einigen High-Performance-Szenarien möglicherweise nicht so leistungsfähig wie HAProxy.

  • AWS Elastic Load Balancing (ELB): ELB ist eine Cloud-native Lösung, die eine nahtlose Integration in AWS-Dienste bietet. Während ELB eine einfache Konfiguration und automatische Skalierung bietet, fehlt ihm die Flexibilität und detaillierte Konfigurierbarkeit von HAProxy.

  • F5 Big-IP: Big-IP ist eine kommerzielle Lösung, die neben Load Balancing auch Funktionen für Anwendungssicherheit und Performance-Management bietet. Im Vergleich zu HAProxy bietet Big-IP mehr Enterprise-Funktionen, ist aber auch kostenintensiver.

Jeder Load Balancer hat seine Stärken und Schwächen, und die Wahl hängt von den spezifischen Anforderungen Ihrer Infrastruktur, Ihrem Budget und Ihren technischen Fähigkeiten ab. HAProxy ist eine ausgezeichnete Wahl für Szenarien, in denen hohe Leistung, Zuverlässigkeit und detaillierte Verkehrskontrolle erforderlich sind.

24.4. Installation

  1. Systemaktualisierung:

    • Debian-basierte Systeme:
      sudo apt-get update

  2. HAProxy installieren:

    • Debian-basierte Systeme:
      sudo apt-get install haproxy

    • Für andere Linux-Distributionen wie CentOS den entsprechenden Paketmanager verwenden.

24.5. Grundlegende Konfiguration

  1. Konfigurationsdatei bearbeiten:

    • Die Standardkonfigurationsdatei befindet sich unter /etc/haproxy/haproxy.cfg.

    • Öffnen Sie die Datei mit einem Texteditor, z.B. sudo nano /etc/haproxy/haproxy.cfg.

  2. Einfachen Load-Balancer konfigurieren:

    • Fügen Sie Abschnitte für defaults, frontend, und backend hinzu.

    • Im frontend-Abschnitt definieren Sie den Port und leiten den Verkehr an backend weiter.

    • Im backend-Abschnitt definieren Sie die Server für den Lastausgleich.

24.6. Beispielkonfiguration

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

frontend http_front
    bind *:80
    default_backend http_back

backend http_back
    balance roundrobin
    server server1 192.168.0.1:80 check
    server server2 192.168.0.2:80 check

24.7. Nach der Konfiguration

  1. Konfiguration überprüfen:

    • sudo haproxy -c -V -f /etc/haproxy/haproxy.cfg

  2. HAProxy neu starten:

    • sudo systemctl restart haproxy

  3. Status überprüfen:

    • sudo systemctl status haproxy

24.8. Zusätzliche Schritte

  • Sicherheitsaspekte: Konfigurieren Sie Ihre Firewall entsprechend.

  • Erweiterte Konfiguration: Für fortgeschrittene Einstellungen konsultieren Sie die HAProxy-Dokumentation.

Wichtig: Diese Anleitung ist grundlegend. Für spezifische Anforderungen und Architekturen sollten Sie sich weitergehend informieren und die offizielle Dokumentation konsultieren.

25. Consul

Consul ist ein Dienstnetzwerk-Tool, das von HashiCorp entwickelt wurde, dem Unternehmen hinter Vagrant und Packer. Es bietet eine vollständige Plattform für die Entdeckung von Diensten, die Konfigurationsverwaltung und die Segmentierung in verteilten Anwendungen und Diensten.

25.1. Kernfunktionen von Consul

Consul bietet viele Funktionen, die dazu beitragen, die Herausforderungen des Betriebs von verteilten Systemen zu bewältigen. Dazu gehören:

  • Dienstentdeckung: Anwendungen können Consul verwenden, um andere Dienste im Netzwerk mit einem DNS- oder HTTP-Interface zu entdecken.

  • Gesundheitsüberprüfungen: Consul kann die Verfügbarkeit von Diensten überwachen und Anwendungen die Anforderungen an gesunde oder ungesunde Instanzen weiterleiten.

  • Key/Value-Speicher: Ein flexibler Key/Value-Speicher ermöglicht die dynamische Konfiguration, das Feature-Flagging, die Koordination, die Führungswahl und vieles mehr.

  • Sichere Dienstekommunikation: Automatische TLS-Verschlüsselung und Identitätsbasierte Autorisierung für Dienste.

25.2. Wie man Consul einsetzt

Consul ist sehr flexibel und kann in einer Vielzahl von Umgebungen und Anwendungsfällen eingesetzt werden. Hier sind einige gängige Einsatzmöglichkeiten:

  • Mikroservicenetze: Consul kann als zentrales Dienstverzeichnis für ein Netzwerk von Mikroservices verwendet werden, um die Dienstentdeckung und -segmentierung zu vereinfachen.

  • Multicloud- und Plattformübergreifende Bereitstellungen: Mit Consul können Sie Dienste über verschiedene Cloud-Plattformen und -Bereitstellungsumgebungen hinweg koordinieren.

  • Konfigurationsverwaltung: Sie können Consul verwenden, um Konfigurationsdaten für Ihre Anwendungen zu speichern und abzurufen.

Um Consul zu installieren und zu verwenden, laden Sie es von der offiziellen HashiCorp-Website herunter und folgen Sie den Anleitungen in der Dokumentation. Ein typisches Consul-Setup könnte mehrere Consul-Server enthalten, die in verschiedenen Teilen Ihres Netzwerks laufen, um Dienste zu entdecken und zu überwachen.

26. Tmux

Terminal-Multiplexer-Tool

Tmux, kurz für 'Terminal Multiplexer', ist ein wertvolles Werkzeug für jeden, der viel Zeit in der Befehlszeile verbringt. Es ermöglicht den Benutzern, mehrere Terminal-Sitzungen in einem einzigen Fenster zu verwalten, und bietet eine Reihe von Funktionen, die die Produktivität erhöhen und den Workflow optimieren.

26.1. Hauptmerkmale von Tmux

  • Sitzungsmanagement: Tmux ermöglicht es Benutzern, Sitzungen zu erstellen, zu trennen, anzuhängen und zwischen ihnen zu wechseln, was es ideal für das gleichzeitige Arbeiten an mehreren Aufgaben oder Projekten macht.

  • Fenster und Bereiche: Innerhalb einer Tmux-Sitzung können Benutzer mehrere Fenster öffnen und jedes Fenster in mehrere Bereiche unterteilen. Dies erleichtert die Navigation und das Multitasking.

  • Anpassbarkeit: Tmux ist hochgradig anpassbar und erlaubt den Benutzern, Schlüsselbindungen zu ändern und das Aussehen des Interfaces anzupassen.

Mit Tmux kannst du deinen Befehlszeilen-Workflow erheblich verbessern, ob du nun ein Entwickler bist, der mehrere Codebasen verwaltet, oder ein Systemadministrator, der verschiedene Server überwacht.

26.2. Installation

Abhängig von deinem Betriebssystem, kann Tmux wie folgt installiert werden:

Ubuntu und andere Linux-Distributionen: sudo apt-get install tmux

Mac OS X: brew install tmux

Windows: Unter Windows empfehle ich die Verwendung von WSL (Windows Subsystem for Linux) und dann den gleichen Befehl wie bei Ubuntu.

26.3. Erste Schritte

Nach der Installation kannst du eine neue Tmux-Sitzung starten, indem du tmux in die Kommandozeile eingibst. Du solltest nun eine neue Tmux-Sitzung sehen mit einer Statusleiste am unteren Rand.

26.4. Sitzungen, Fenster und Bereiche

In Tmux gibt es Konzepte wie Sitzungen, Fenster und Bereiche.

Sitzung: Eine Sitzung ist eine unabhängige Arbeitsumgebung mit einer eigenen Gruppe von Fenstern.

Fenster: Ein Fenster nimmt den gesamten Bildschirm ein und kann mehrere Bereiche enthalten.

Bereiche: Ein Fenster kann in mehrere Bereiche unterteilt werden.

26.5. Grundlegende Befehle

Um Befehle an Tmux zu senden, verwendest du den Tmux-Befehlspräfix, der standardmäßig Ctrl-b ist, gefolgt von einem anderen Schlüssel. Hier sind einige grundlegende Befehle:

Ctrl-b "

Teilt das aktuelle Fenster horizontal.

Ctrl-b %

Teilt das aktuelle Fenster vertikal.

Ctrl-b o

Wechselt den Fokus zwischen Bereichen.

Ctrl-b c

Erstellt ein neues Fenster.

Ctrl-b n

Wechselt zum nächsten Fenster.

Ctrl-b l

Wechselt zum letzten Fenster.

Ctrl-b d

Trennt die aktuelle Sitzung (diese läuft weiter im Hintergrund).

26.6. Sitzungsmanagement

Tmux ermöglicht es dir, Sitzungen zu verwalten, die im Hintergrund laufen können. Hier sind einige Befehle dazu:

tmux new -s mysession

Erstellt eine neue Sitzung namens "mysession".

tmux attach -t mysession

Hängt sich an eine vorhandene Sitzung namens "mysession" an.

tmux switch -t mysession

Wechselt zu einer vorhandenen Sitzung namens "mysession".

tmux list-sessions

Listet alle aktiven Sitzungen auf.

Bitte beachte, dass die Tastenkombinationen und Befehle konfigurierbar sind und durch die tmux-Konfigurationsdatei (normalerweise ~/.tmux.conf) geändert werden können.

Mit diesen grundlegenden Befehlen und Konzepten bist du in der Lage, effektiv mit Tmux zu arbeiten und kannst deinen Workflow verbessern. Es gibt natürlich noch viele weitere Befehle und Möglichkeiten zur Anpassung, die du erkunden kannst, wenn du mit Tmux vertrauter bist.

27. Vagrant

Vagrant ist ein Open-Source-Tool, das von HashiCorp entwickelt wurde, um die Erstellung und Verwaltung von virtuellen Maschinen-Umgebungen zu vereinfachen. Vagrant ist plattformunabhängig und unterstützt eine Vielzahl von Betriebssystemen wie Linux, Windows und Mac. Darüber hinaus unterstützt es auch eine Vielzahl von Virtualisierungsplattformen, auch Provider genannt, wie VirtualBox, VMware, Hyper-V und mehr.

27.1. Vorteile von Vagrant

  • Einfache Verwendung: Vagrant bietet eine einfache Befehlszeilenschnittstelle zur Verwaltung von virtuellen Maschinen. Mit einem einzigen Befehl können Sie eine VM starten, stoppen, löschen oder neu starten.

  • Reproduzierbarkeit: Mit Vagrant können Sie eine "Vagrantfile" -Konfigurationsdatei erstellen, die die Anforderungen Ihrer VM definiert. Dies stellt sicher, dass jeder, der das Vagrantfile hat, genau die gleiche VM-Umgebung erstellen kann.

  • Integration: Vagrant integriert sich nahtlos mit bestehenden Konfigurationsverwaltungstools wie Chef, Puppet, Ansible und anderen, um die Konfiguration und Verwaltung von VMs zu vereinfachen.

27.2. Wie man Vagrant einsetzt

Um Vagrant zu verwenden, folgen Sie den folgenden grundlegenden Schritten:

  1. Installieren Sie Vagrant: Laden Sie Vagrant von der offiziellen Website herunter und installieren Sie es auf Ihrem System.

  2. Erstellen Sie eine Vagrantfile: Eine Vagrantfile ist eine Konfigurationsdatei, die Vagrant sagt, welche Art von Maschine und Ressourcen Sie benötigen, und wie diese konfiguriert werden sollen.

  3. Starten Sie die VM: Verwenden Sie das 'vagrant up'-Kommando, um die VM zu starten. Vagrant wird die VM entsprechend Ihrer Vagrantfile erstellen und konfigurieren.

  4. Verbinden Sie sich mit der VM: Verwenden Sie das 'vagrant ssh'-Kommando, um sich mit Ihrer VM zu verbinden und darauf zu arbeiten.

  5. Beenden und Löschen Sie die VM: Wenn Sie mit Ihrer VM fertig sind, können Sie das 'vagrant halt'-Kommando verwenden, um sie zu stoppen, und das 'vagrant destroy'-Kommando, um sie zu löschen.

Vagrant bietet eine effiziente und flexible Möglichkeit, mit virtuellen Maschinen zu arbeiten. Ob Sie eine isolierte Entwicklungsumgebung benötigen oder eine komplexe VM-Infrastruktur verwalten, Vagrant kann Ihnen dabei helfen.

28. Gegenüberstellung: Ansible, Chef, Puppet und SaltStack

Die Gegenüberstellung von Ansible, Chef, Puppet und SaltStack offenbart unterschiedliche Merkmale und Vorteile, die auf verschiedene organisatorische Bedürfnisse im Bereich der Konfigurationsverwaltung zugeschnitten sind:

28.1. Ansible:

  • Typ: Überwiegend agentenlos (unterstützt auch agentenbasiert).

  • Hauptmerkmale: Automatisiert Cloud-Ökosysteme, Anwendungen, Netzwerke, Container, Sicherheit.

  • Kompatibilität: Funktioniert mit vielen Linux-Versionen, macOS, FreeBSD, Solaris; basiert auf Python.

  • Ansatz: Verwendet eine Kombination aus prozeduraler und deklarativer Sprache; zielt auf gewünschte Zustände ab.

  • Vorteil: Vereinfacht IT-Bereitstellungen mit menschenlesbaren Datenbeschreibungen und Modulen für Automatisierung.

28.2. Chef Infrastructure Management:

  • Typ: Agentenbasiert.

  • Hauptmerkmale: Automatisiert über Cloud, physische und virtuelle Ökosysteme; unterstützt AIOps.

  • Kompatibilität: Unterstützt verschiedene Unix-, Linux- und Windows-Versionen.

  • Ansatz: Verwendet Ruby; betont Skalierbarkeit und präventive Tests für Änderungen.

  • Vorteil: Gut für Umgebungen, in denen Sicherheit entscheidend ist; ermöglicht autonome Knoten.

28.3. Puppet Enterprise:

  • Typ: Agentenlos.

  • Hauptmerkmale: Betont Service-Stabilität und -Zuverlässigkeit; verringert Änderungsfehlerraten.

  • Kompatibilität: Breite Unterstützung für moderne Betriebssysteme.

  • Ansatz: Verwendet Infrastruktur als Code mit Zustandsdurchsetzung.

  • Vorteil: Vereinfacht das Management und ermöglicht eine effizientere Handhabung von mehr Ressourcen.

28.4. SaltStack:

  • Typ: Bietet sowohl agentenbasierte (Minions oder Proxy-Agenten) als auch agentenlose (SSH/WinRM) Möglichkeiten.

  • Hauptmerkmale: Ereignisgesteuerte Automatisierung; bewältigt komplexe Szenarien wie mehrstufige Patch-Vorgänge.

  • Kompatibilität: Unterstützt Windows, verschiedene Linux-Distributionen und Unix.

  • Ansatz: Python-basiert mit YAML-Unterstützung; kombiniert imperativen und deklarativen Ausführungsansatz.

  • Vorteil: Passt sich gut an skalierende Umgebungen mit komplexen Anforderungen an.

28.5. Fazit

Das richtige Werkzeug auswählen: Die Entscheidung dreht sich nicht darum, das beste Werkzeug auf dem Markt zu finden, sondern das passendste für die spezifischen Bedürfnisse einer Organisation. Zu berücksichtigende Faktoren sind: - Agent vs. Agentenlos: Ansible und Puppet sind agentenlos; Chef verwendet Agenten, und SaltStack bietet beides. - OS-Kompatibilität: Dies kann ein entscheidender Faktor sein, abhängig von der Infrastruktur der Organisation. - Teamkompetenz: Die Vertrautheit mit den zugrunde liegenden Programmiersprachen (z. B. Python für Ansible, Ruby für Chef) ist wichtig. - Spezifische organisatorische Anforderungen: Jedes Werkzeug hat einzigartige Stärken, die für verschiedene Umgebungen und Bedürfnisse geeignet sind.

Letztendlich werden die Stärken und Kompetenzen des IT-Teams maßgeblich beeinflussen, welches Konfigurationsverwaltungsprodukt am geeignetsten ist.

29. WIP: GitOps / DevOps / SRE: Konzepte & Tools

Prozessverbesserungsansatz der Softwareentwicklung und Systemadministration

Das Kernstück der DevOps-Organisationskultur ist die Aufhebung der Trennung zwischen Entwicklung und Operations zugunsten einer Kooperation.

29.1. GitOps

  • Alles wird in Git Repositories gespeichert

  • Alle Änderungen werden ausschließlich aus Git gelesen

  • incl. Infrastruktur (Infrastruktur as Code)

  • Voraussetzung für erfolgreiche Automatisierung

29.2. DevOps

  • Begriff setzt sich aus "Dev" (Development) und "Ops" (Operations) zusammen

  • zuvor getrennte Rollen wie Entwicklung, IT-Betrieb, Security arbeiten damit koordiniert zusammen

  • Bessere und zuverlässigere Produkte entstehen

  • Schnellere Reaktion auf Anforderungen vom Kunden

Die Vorteile: Produktiver entwickeln, weniger Abhängigkeiten, Qualitätssteigerung

ToDo

30. WIP: DevOps - Konzepte

  • Source Code Management

  • Package Management

  • CI/CD

  • Container Orchestration

  • Cloud

  • Infrastructure as Code

  • Continuous Monitoring

30.1. 1. Source Code Management (SCM)

Tools: Git, Gitea, GitLab, GitHub

30.2. 2. Package Management

Tools: DockerHub, Jfrog, Nexus, GitLab

30.3. 3. CI/CD Concept

devops

Tools: Jenkins, Gitlab CI/CD

30.4. 4. Container Orchestration

Tools: Kubernetes, OpenShift

30.5. 5. Cloud

Tools: AWS, Google Cloud, Oracle Cloud, Microsoft Azure

30.6. 6. Infrastructure as Code Concept (IaC)

Tools: Terraform, Ansible

30.7. 7. Continuous Monitoring

Tools: Nagios, Prometheus

31. WIP: Fähigkeiten für einen DevOps-Ingenieur

Ein DevOps-Ingenieur muss eine Reihe von technischen und weichen Fähigkeiten besitzen. Hier sind einige der wichtigsten:

31.1. 1. Kenntnisse von CI/CD-Tools

Continuous Integration / Continuous Delivery - Tools wie Jenkins, Bamboo oder GitLab CI sind wesentlich für den Automatisierungsprozess in DevOps.

31.2. 2. Kenntnisse in Cloud-Diensten

Vertrautheit mit Plattformen wie AWS, Google Cloud oder Microsoft Azure ist von Vorteil, da viele Unternehmen ihre Infrastrukturen in der Cloud haben.

31.3. 3. Infrastruktur als Code (IaC)

Erfahrung mit Tools wie Ansible, Terraform oder Chef, die zur Automatisierung von Infrastrukturaufgaben verwendet werden.

31.4. 4. Containerisierung und Orchestrierung

Kenntnisse in Docker und Kubernetes sind oft erforderlich, um den Prozess der Softwarebereitstellung und -verwaltung zu optimieren.

31.5. 5. Programmier- und Skripterstellungsfähigkeiten

Grundkenntnisse in Programmiersprachen wie Python, Ruby oder Java und Skripting-Sprachen wie Bash oder PowerShell sind oft hilfreich.

31.6. 6. Systemadministration

Verständnis für Netzwerkprotokolle, Betriebssysteme und Sicherheit.

31.7. 7. Weiche Fähigkeiten

Starke Kommunikationsfähigkeiten, Problemlösungsfähigkeiten und die Fähigkeit, in einem Team zu arbeiten, sind ebenfalls wichtig in der Rolle eines DevOps-Ingenieurs.

32. Semantische Versionsbezeichnungen

Um semantische Versionsbezeichnung in einer GitLab-Pipeline zu realisieren, können Sie die folgenden Schritte befolgen:

  1. Generieren Sie eine neue Versionsnummer basierend auf den Anforderungen der semantischen Versionsbezeichnung. Hierzu können Sie ein Skript verwenden, das in Ihrem Projekt nach spezifischen Commit-Messages sucht, um zu bestimmen, ob es sich um eine Major-, Minor- oder Patch-Änderung handelt.

  2. In Ihrem .gitlab-ci.yml-Datei, definieren Sie einen Job, der das Skript ausführt und die neue Versionsnummer generiert. Speichern Sie diese Nummer als CI/CD-Variable für die nachfolgenden Jobs.

  3. Verwenden Sie diese Versionsnummer in Ihren nachfolgenden Jobs - z.B. beim Bauen, Testen und Bereitstellen Ihrer Anwendung.

  4. Schließlich, in einem separaten Job, erstellen Sie ein neues Git-Tag mit dieser Versionsnummer und pushen es zurück in Ihr Repository.

32.1. Beispiel

Hier ist ein einfaches Beispiel für .gitlab-ci.yml:

stages:
  - versioning
  - build
  - deploy

versioning:
  stage: versioning
  script:
    - VERSION=$(./generate-version.sh) # Verwenden Sie Ihr eigenes Skript zur Generierung der Version
    - echo "VERSION=$VERSION" >> build.env

build:
  stage: build
  script:
    - source build.env
    - echo "Building version $VERSION"
    # Fügen Sie hier Ihren Build-Code ein

deploy:
  stage: deploy
  script:
    - source build.env
    - echo "Deploying version $VERSION"
    # Fügen Sie hier Ihren Deployment-Code ein
  after_script:
    - git tag $VERSION
    - git push origin $VERSION

In diesem Beispiel verwendet generate-version.sh Ihr eigenes Skript zur Generierung der Version. Sie können es so anpassen, dass es die Anforderungen der semantischen Versionsbezeichnung erfüllt.

Bitte beachten Sie, dass Sie geeignete Berechtigungen benötigen, um Tags zu Ihrem Repository hinzuzufügen. Auch kann das Script je nach den spezifischen Anforderungen Ihres Projekts variieren.

33. WIP: AWX

coming soon

34. WIP: Ansible Semaphore

New UI for a good old Ansible

Ansible Semaphore is beautiful web interface for running Ansible playbooks. You do not need to change your playbooks to start using it.

34.1. Installation

sudo snap install semaphore

35. WIP: Ansible: Eine Einführung und Leitfaden

35.1. Einführung

In der heutigen Welt der IT ist Automatisierung unerlässlich. Es ist wichtig, effizient zu sein und gleichzeitig sicherzustellen, dass unsere Systeme ordnungsgemäß konfiguriert sind. Hier kommt Ansible ins Spiel. Ansible ist ein mächtiges Werkzeug für die Automatisierung, das das Konfigurationsmanagement, die Anwendungsbereitstellung, die Netzwerkautomatisierung und viele andere IT-Anforderungen erleichtert.

35.2. Warum Ansible?

Ansible ist ein Open-Source-Tool für die Automatisierung von Software-Bereitstellungen, Konfigurationsmanagement und Orchestrierung von Aufgaben. Es ist einfach zu verwenden, da es keine Agenten-Software und keine zusätzliche benutzerdefinierte Sicherheitsinfrastruktur erfordert. Darüber hinaus verwendet es eine sehr einfache Sprache (YAML, in Form von Ansible Playbooks), die es Systemadministratoren und Entwicklern ermöglicht, Aufgaben einfach zu beschreiben.

35.3. Was ist Ansible?

Ansible ist ein radikal einfaches IT-Automatisierungssystem. Es behandelt die Konfiguration von Systemen, die Bereitstellung von Software und das Orchestrieren komplexerer IT-Aufgaben wie kontinuierliche Bereitstellungen oder die Null-Ausfallzeit-Rolling-Updates.

35.4. Grundlegende Konzepte von Ansible

35.4.1. Inventory

Das Ansible Inventory ist eine Liste von Knoten, die als Ziel für die Ansible Playbooks dienen. Ein Knoten kann ein Server, ein Switch, ein Router oder jedes andere Gerät sein, das über das Netzwerk zugänglich ist. Die Knoten werden im Inventory normalerweise durch ihre IP-Adresse oder ihren Hostnamen identifiziert. Sie können auch Knoten in Gruppen organisieren, um bestimmte Konfigurationen auf eine Gruppe von Knoten anzuwenden.

35.4.2. Playbooks

Ansible Playbooks sind YAML-Dateien, die Ihre Automatisierungs-Jobs beschreiben. Ein Playbook kann aus einem oder mehreren 'Plays' bestehen, und ein 'Play' ist im Wesentlichen eine Reihe von Aufgaben, die auf den im Inventory definierten Zielknoten ausgeführt werden. Diese Aufgaben werden sequenziell ausgeführt, von oben nach unten in der Datei.

35.4.3. Rollen

Rollen in Ansible bieten eine Methode zur Gruppierung verwandter Aufgaben und zur Wiederverwendung von Code. Sie können eine Rolle erstellen, die eine bestimmte Funktion ausführt, wie zum Beispiel das Einrichten eines Web-Servers, und diese Rolle dann in verschiedenen Playbooks verwenden. Rollen erleichtern auch die Zusammenarbeit und die Code-Organisation, indem sie eine standardisierte Datei- und Verzeichnisstruktur bereitstellen.

35.4.4. Module

Module sind die 'Werkzeuge' in Ihrer Ansible-Werkzeugkiste. Sie führen bestimmte Aufgaben aus und können unabhängig oder in Playbooks verwendet werden, um komplexe Aufgaben auszuführen. Es gibt Hunderte von eingebauten Modulen in Ansible, die eine breite Palette von Funktionen abdecken.

35.5. Ein einfaches Ansible-Beispiel

35.6. Fazit

Die Kraft von Ansible liegt in seiner Einfachheit. Es nutzt einfache, menschenlesbare YAML-Playbooks, um komplexe Aufgaben zu automatisieren. Die grundlegenden Konzepte - Inventar, Playbooks, Rollen und Module - sind einfach zu verstehen und doch unglaublich mächtig in ihrer Anwendung. Mit diesen Grundlagen sind Sie gut gerüstet, um mit Ansible loszulegen und Ihre Automatisierungsprojekte auf die nächste Stufe zu bringen.

36. WIP: Best Practices for managing BASH Scripts

37. WIP: Caching

38. WIP: Argo-Rollouts

39. WIP: Argo Workflows

40. WIP: FluxCD

41. WIP: Hetzner - Cloud

42. WIP: Docker

Docker logo

42.1. Was ist Docker?

42.2. Funktionsweise

42.3. Häufig genutzte Commands

43. WIP: Crossplane

logo

43.1. What is Crossplane

Crossplane is a framework for building cloud native control planes without needing to write code. It has a highly extensible backend that enables you to build a control plane that can orchestrate applications and infrastructure no matter where they run, and a highly configurable frontend that puts you in control of the schema of the declarative API it offers.

Crossplane is a Cloud Native Compute Foundation project.

44. WIP: Databases - An Overview

44.1. Postgesql

44.2. MariaDB

44.3. MongoDB

45. WIP: GitLab

Webanwendung zur Versionsverwaltung auf Git-Basis

  • Issue-Tracking-System mit Kanban-Board

  • Continuous Integration und Continuous Delivery (CI/CD)

  • Container-Registry

  • API zur Steuerung von Gitlab

46. WIP: Helm

47. WIP: Helm Dashboard

48. WIP: K8e - Kubernetes Easy Engine (k8e)

49. WIP: Kubernetes - debug

coming soon

50. WIP: k3s - Lightweight Kubernetes

51. WIP: K8up - Kubernetes Backup Operator

K8up (pronounced /keɪtæpp/ or simply "ketchup") is a Kubernetes Operator distributed via a Helm chart, compatible with OpenShift and plain Kubernetes. It allows cluster operators to:

  • Backup all PVCs marked as ReadWriteMany, ReadWriteOnce or with a specific label.

  • Perform individual, on-demand backups.

  • Schedule backups to be executed on a regular basis.

  • Schedule archivals (for example to AWS Glacier), usually executed in longer intervals.

  • Perform "Application Aware" backups, containing the output of any tool capable of writing to stdout.

  • Check the backup repository for its integrity.

  • Prune old backups from a repository.

  • Restore backups with the help of the k8up CLI tool.

  • Based on top of Restic, it can store backups in any S3-compatible storage, such as Amazon S3 or Minio.

  • K8up is written in Go and is an Open Source project hosted at GitHub.

51.1. How to Install K8up

coming soon

52. WIP: kOps - Kubernetes Operations

The easiest way to get a production grade Kubernetes cluster up and running.

52.1. What is kOps?

We like to think of it as kubectl for clusters.

kops will not only help you create, destroy, upgrade and maintain production-grade, highly available, Kubernetes cluster, but it will also provision the necessary cloud infrastructure.

AWS (Amazon Web Services) and GCE (Google Cloud Platform) are currently officially supported, with DigitalOcean, Hetzner and OpenStack in beta support, and Azure in alpha.

52.2. Features

  • Automates the provisioning of Highly Available Kubernetes clusters

  • Built on a state-sync model for dry-runs and automatic idempotency

  • Ability to generate Terraform

  • Supports zero-config managed kubernetes add-ons

  • Command line autocompletion

  • YAML Manifest Based API Configuration

  • Templating and dry-run modes for creating Manifests

  • Choose from most popular CNI Networking providers out-of-the-box

  • Multi-architecture ready with ARM64 support

  • Capability to add containers, as hooks, and files to nodes via a cluster manifest

52.3. Installing

52.3.1. Prerequisite

kubectl is required, see here.

52.3.2. Linux

1
2
3
curl -Lo kops https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64
chmod +x kops
sudo mv kops /usr/local/bin/kops

53. WIP: Kind - Kubernetes in Docker

Kind ist ein Werkzeug zum Betreiben lokaler Kubernetes-Cluster unter Verwendung von Docker-Container „Knoten". Kind wurde hauptsächlich zum Testen von Kubernetes selbst entwickelt, kann aber auch für lokale Entwicklung oder CI verwendet werden.

53.1. Installation

Linux
1
2
3
4
5
6
# For AMD64 / x86_64
[ $(uname -m) = x86_64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
# For ARM64
[ $(uname -m) = aarch64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-arm64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

53.2. Create Cluster

54. WIP: Kubespay

54.1. Was ist kubespay

Kubespray is a composition of Ansible playbooks, inventory, provisioning tools, and domain knowledge for generic OS/Kubernetes clusters configuration management tasks.

Kubespray provides:

Highly available cluster. Composable (Choice of the network plugin for instance).

Supports most popular Linux distributions:

Flatcar Container Linux by Kinvolk Debian Bullseye, Buster, Jessie, Stretch Ubuntu 16.04, 18.04, 20.04, 22.04 CentOS/RHEL 7, 8, 9 Fedora 35, 36 Fedora CoreOS openSUSE Leap 15.x/Tumbleweed Oracle Linux 7, 8, 9 Alma Linux 8, 9 Rocky Linux 8, 9 Kylin Linux Advanced Server V10 Amazon Linux 2 Continuous integration tests.

55. WIP: Kubesphere

55.1. Was ist Kubesphere?

KubeSphere ist eine offene Plattform für die Unternehmensklasse, die auf Kubernetes aufbaut und Anwendern eine einfache Möglichkeit zur Konfiguration, Bereitstellung und Verwaltung von Anwendungen auf Kubernetes bietet, unabhängig davon, ob diese Anwendungen in öffentlichen Clouds, privaten Clouds oder On-Premises-Servern bereitgestellt werden.

KubeSphere bietet eine Reihe von Funktionen wie Multi-Tenancy-Management, Netzwerkverwaltung, Speicherverwaltung, DevOps, Anwendungsmanagement und mehr. Es unterstützt auch mehrere Netzwerk-Plugins, Integration von Persistent-Volume-Providern und Plugin-Erweiterungen, um die Komplexität der Kubernetes-Plattform zu minimieren.

Die Plattform wurde entwickelt, um Unternehmen dabei zu helfen, ihre Microservices-Architekturen und DevOps-Prozesse zu optimieren, und bietet einen einheitlichen Bereich zur Verwaltung ihrer gesamten Infrastruktur und Anwendungen.

56. WIP: KubeVela

56.1. Was ist KubeVela?

KubeVela ist eine einfach zu bedienende und dennoch extrem flexible Kubernetes-Plattform für Entwickler. KubeVela bietet eine Reihe von Funktionen, die Entwicklern helfen, ihre Anwendungen effizient zu entwickeln, zu testen, zu bereitstellen und zu skalieren.

56.2. Vorteile von KubeVela

Die Verwendung von KubeVela bietet eine Reihe von Vorteilen:

  • Einfache Bedienung: KubeVela bietet eine vereinfachte Benutzererfahrung, die es Entwicklern ermöglicht, sich auf das Schreiben von Code zu konzentrieren, anstatt sich mit Infrastrukturdetails zu befassen.

  • Extreme Flexibilität: Mit KubeVela können Entwickler jede Art von Anwendung auf Kubernetes bereitstellen, von einfachen Microservices bis hin zu komplexen Anwendungen mit mehreren Komponenten.

  • Applikationsorientierter Ansatz: Im Gegensatz zu anderen Kubernetes-Plattformen, die infrastrukturorientiert sind, ist KubeVela anwendungsorientiert. Dies bedeutet, dass die Anwendung und nicht die Infrastruktur im Mittelpunkt steht.

  • Interoperabilität: KubeVela ist vollständig kompatibel mit allen bestehenden Kubernetes-Erweiterungen und -Technologien. Dies bedeutet, dass Sie KubeVela nahtlos in Ihre bestehende Kubernetes-Infrastruktur integrieren können.

56.3. Wie man KubeVela einsetzt

KubeVela kann in jeder Kubernetes-Umgebung verwendet werden. Sie können es auf Ihrem lokalen Rechner, in Ihrer privaten Cloud oder in jeder öffentlichen Cloud, die Kubernetes unterstützt, einsetzen. Um KubeVela zu verwenden, installieren Sie es einfach in Ihrer Kubernetes-Umgebung und verwenden dann das KubeVela-CLI, um Ihre Anwendungen zu definieren und zu verwalten.

57. WIP: Loadbalancer for K8s

57.1. HAPROXY

Die Installation, Konfiguration und Nutzung eines HAProxy-Load-Balancers auf einem Ubuntu-System erfolgt in mehreren Schritten. Hier ist eine grundlegende Anleitung:

57.1.1. Installation von HAProxy

  1. Update des Systems: Aktualisieren Sie zuerst Ihre Paketlisten und Pakete, um sicherzustellen, dass alles auf dem neuesten Stand ist. ` sudo apt update sudo apt upgrade `

  2. Installation von HAProxy: ` sudo apt install haproxy `

57.1.2. Grundkonfiguration von HAProxy

  1. Backup der Konfigurationsdatei: Bevor Sie Änderungen vornehmen, erstellen Sie eine Sicherungskopie der ursprünglichen Konfigurationsdatei. ` sudo cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.original `

  2. Bearbeiten der Konfigurationsdatei: Öffnen Sie die Konfigurationsdatei mit einem Texteditor Ihrer Wahl (z.B. nano oder vim). ` sudo nano /etc/haproxy/haproxy.cfg `

  3. Konfiguration anpassen: Passen Sie die Konfigurationsdatei an Ihre Anforderungen an. Sie müssen Abschnitte für defaults, frontend und backend definieren.

    • defaults: Allgemeine Einstellungen wie Zeitlimits.

    • frontend: Definiert, wie HAProxy Anfragen von Clients empfängt.

    • backend: Definiert, an welche Server die Anfragen weitergeleitet werden sollen.

      .Beispiel für eine einfache Konfiguration, die den HTTP-Verkehr auf zwei Webserver verteilt:
      [source, yaml]
      ----
      frontend http_front
        bind *:80
        default_backend http_back
      backend http_back
        balance roundrobin
        server web1 192.168.1.1:80 check
        server web2 192.168.1.2:80 check
      ----

57.1.3. HAProxy starten und testen

  1. HAProxy neu starten: Nachdem Sie die Konfigurationsdatei bearbeitet haben, müssen Sie HAProxy neu starten, um die Änderungen zu übernehmen.

    sudo systemctl restart haproxy
    ```
  2. Status überprüfen: Stellen Sie sicher, dass HAProxy ordnungsgemäß läuft. ` sudo systemctl status haproxy `

  3. Testen: Überprüfen Sie, ob HAProxy wie erwartet funktioniert, indem Sie auf die IP-Adresse oder den Domainnamen Ihres HAProxy-Servers zugreifen.

57.1.4. Zusätzliche Schritte und Tipps

  • Sicherheit: Stellen Sie sicher, dass Ihre HAProxy-Installation sicher ist. Dies kann die Einrichtung von Firewalls, die Beschränkung des Zugriffs auf bestimmte IPs und die Verwendung von HTTPS umfassen.

  • Logging: Konfigurieren Sie Logging, um Probleme zu diagnostizieren und den Verkehr zu überwachen.

  • Erweiterte Konfigurationen: HAProxy bietet viele erweiterte Optionen wie SSL/TLS-Terminierung, Session-Persistenz, HTTP/2-Unterstützung und mehr.

58. WIP: MDR - Rancher

58.1. Helm install

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

58.2. Rancher Helm Chart

helm repo add rancher-stable https://releases.rancher.com/server-charts/stable

58.3. Load Chart for offline use

helm pull rancher-stable/rancher --version=v2.8.1

58.4. Create secrets for Rancher-Helm Install

kubectl -n cattle-system create secret generic tls-ca --from-file=cacerts.pem=certs/tls-ca-bundle.pem
kubectl -n cattle-system create secret tls rancher-tls --cert=certs/rancher.adin.mdr.de.chain.pem --key=certs/rancher.adin.mdr.de.key
kubectl create secret tls rancher-tls --cert=certs/rancher.adin.mdr.de.pem

58.5. Install Rancher offline

helm install rancher ./rancher-2.8.1.tgz     --namespace cattle-system     --set hostname=rancher.adin.mdr.de     --set rancherImage=harbor.container.mdr.de/rancher/rancher     --set ingress.tls.source=secret     --set useBundledSystemChart=true

58.6. Upgrade Rancher

helm upgrade rancher rancher-stable/rancher   --namespace cattle-system   --set hostname=l-con1-t.adin.mdr.de  --set replicas=1   --version=2.8.1

59. WIP: RKE2 - Rancher

coming soon

59.1. Install

59.1.1. ARM64

1
2
3
4
5
6
7
8
9
mkdir /root/rke2-artifacts && cd /root/rke2-artifacts/
wget https://github.com/rancher/rke2/releases/download/v1.27.3%2Brke2r1/rke2-images.linux-arm64.tar.gz
wget https://github.com/rancher/rke2/releases/download/v1.27.3%2Brke2r1/rke2.linux-arm64.tar.gz
wget https://github.com/rancher/rke2/releases/download/v1.27.3%2Brke2r1/sha256sum-arm64.txt
curl -sfL https://get.rke2.io --output install.sh
INSTALL_RKE2_TYPE=agent INSTALL_RKE2_ARTIFACT_PATH=/root/rke2-artifacts sh install.sh

systemctl enable rke2-server
systemctl start rke2-server
Kubectl
1
2
3
curl -LO https://dl.k8s.io/release/v1.28.4/bin/linux/arm64/kubectl
install kubectl /usr/local/bin
rm kubectl -f
k9s
1
2
3
4
curl -LO https://github.com/derailed/k9s/releases/download/v0.29.1/k9s_Linux_arm64.tar.gz
tar xvzf k9s_Linux_arm64.tar.gz k9s
install k9s /usr/local/bin
rm -f k9s k9s_Linux_arm64.tar.gz

59.2. Create Aliase

1
2
3
4
alias kcns='kubectl config set-context --current --namespace'
alias k='kubectl'
alias kpo='kubectl get po -A'
alias kepo='kubectl get po -A | grep -v "Running|Complited"'

60. WIP: Longhorn

coming soon

61. WIP: Velero

Velero (formerly Heptio Ark) gives you tools to back up and restore your Kubernetes cluster resources and persistent volumes. You can run Velero with a cloud provider or on-premises. Velero lets you:

  • Take backups of your cluster and restore in case of loss.

  • Migrate cluster resources to other clusters.

  • Replicate your production cluster to development and testing clusters.

Velero consists of:

  • server that runs on your cluster

  • command-line client that runs locally

62. WIP: Kubernetes

Kubernetes logo

62.7. Kubernetes - Backup / Restore

62.8. Kubernetes Operator

63. WIP: Kasten

64. WIP: Keycloak

65. WIP: Kiali

66. WIP: Kustomize

67. WIP: Satelite - Package Manager

coming soon

68. WIP: Monitoring

69. WIP: OpenLens

70. WIP: Planing - System Blueprints

71. WIP: Python

Python ist eine beliebte, hochrangige Programmiersprache, die für ihre Lesbarkeit und einfache Syntax bekannt ist. Sie wird in vielen Bereichen wie Webentwicklung, Data Science, künstliche Intelligenz, Maschinelles Lernen und mehr verwendet.

71.1. Einsatz

Mit Python können Sie viele Dinge tun, zum Beispiel:

  • Webseiten und Web-Apps erstellen (mit Frameworks wie Django oder Flask)

  • Daten analysieren und visualisieren (mit Bibliotheken wie pandas, NumPy und matplotlib)

  • Maschinelles Lernen und künstliche Intelligenz implementieren (mit Tools wie scikit-learn und TensorFlow)

71.2. Lernen

Um Python zu lernen, können Sie die folgenden Schritte befolgen:

Grundlagen erlernen: Beginnen Sie mit den Grundlagen der Programmierung und der Python-Syntax. Es gibt viele kostenlose Ressourcen online, wie zum Beispiel die offizielle Python-Dokumentation oder Websites wie Codecademy und Coursera.

Praxisprojekte durchführen: Wenden Sie das, was Sie gelernt haben, auf echte Projekte an. Das kann so einfach sein wie ein Programm, das Text in der Konsole ausgibt, oder so komplex wie eine voll funktionsfähige Web-App.

Erweiterung Ihrer Kenntnisse: Lernen Sie über spezifische Bibliotheken und Frameworks in den Bereichen, die Sie am meisten interessieren, wie z.B. Django für Webentwicklung oder TensorFlow für Maschinelles Lernen.

Gemeinschaft beitreten: Es gibt eine riesige und unterstützende Python-Gemeinschaft online. Foren wie Stack Overflow und Reddit können hilfreiche Ressourcen sein, um Fragen zu stellen und Antworten auf häufige Probleme zu finden.

72. WIP: Quarkus

72.1. Einleitung

Quarkus ist ein Kubernetes-native Java-Stack, der für die GraalVM und HotSpot angepasst ist.

72.2. Vorteile

Quarkus zielt darauf ab, das Produktivitätsparadigma von Plattformen wie Node.js, Ruby on Rails und Spring Boot in den Java-Ökosystem zu bringen, während es gleichzeitig schneller Boot-Zeit, geringere Speicherauslastung, verbesserte Entwicklerfreundlichkeit und bessere Cloud-Integration bietet.

72.3. Merkmale

  • Live Coding: Änderungen werden in Echtzeit in Ihrer laufenden Anwendung angezeigt.

  • Imperative und Reaktive Stile: Quarkus vereinheitlicht die imperative und reaktive Programmierung.

  • Standardsbasiert: Quarkus verwendet bekannte Enterprise-APIs und Standards.

  • Kubernetes-native: Es ist speziell für GraalVM und HotSpot entwickelt und optimiert worden, um die Anforderungen moderner Container und Cloud-Plattformen zu erfüllen.

73. WIP: Teleport

73.1. Was ist Teleport

Identity-Native Infrastructure Access

Teleport replaces the #1 source of data breaches — secrets — with true identity to deliver phishing-proof zero trust access for every engineer and service connected to your global infrastructure.

74. WIP: Artifactories

74.1. Harbor

74.2. Nexus

74.3. Registry (docker)

74.4. GitLab

75. WIP: Vaults

76. Sammlung nützlicher Befehle und Scripte

76.1. git

Abfrage und Sortierung von git-tags (grep -v "-" → blendet rc aus):
git tag --sort=-v:refname | grep -v "-" | head -n 3
Ausgabe:
v16.6.1
v16.6.0
v16.5.3
Abfrage und Sortierung von git remote repos
# Abfrage von rke2 git repo
git -c 'versionsort.suffix=-' ls-remote --exit-code --refs --sort='version:refname' \
    --tags https://github.com/rancher/rke2.git '*.*.*'  | grep -v - | \
    grep "v1.26" | tail --lines=1 | cut --delimiter='/' --fields=3
Ausgabe:
# Latest version from rke2 for MINOR release v1.26
v1.26.13+rke2r1

76.2. kubectl

change namespace
kubectl config set-context --current --namespace=xxx
Show details of k8s nodes
kubectl describe nodes
# or
kubectl describe node <nodename>

77. Auflistung der Software Versionen

Softwarename Version Commit Datum Repo URL

Ansible

v2.16.4

2024-02-26

https://github.com/ansible/ansible.git

Argo-Events

v1.9.1

2024-02-13

https://github.com/argoproj/argo-events.git

Argo-Rollout

v1.6.6

2024-02-12

https://github.com/argoproj/argo-rollouts.git

Argo-Workflows

v3.5.5

2024-02-16

https://github.com/argoproj/argo-workflows.git

ArgoCD

v2.10.1

2024-02-14

https://github.com/argoproj/argo-cd.git

Asciidoctor

v2.0.21

2024-02-20

https://github.com/asciidoctor/asciidoctor.git

Awx

23.9.0

2024-02-26

https://github.com/ansible/awx.git

Fleet

v0.9.0

2023-10-17

https://github.com/rancher/fleet.git

Gitlab

v16.9.1

2024-02-20

https://gitlab.com/gitlab-org/gitlab-foss.git

Gitlab-docker

2024-02-22

https://github.com/zengxs/gitlab-docker.git

Gitlab-runner

v16.9.1

2024-02-28

https://gitlab.com/gitlab-org/gitlab-runner.git

Harbor

v2.10.0

2023-12-14

https://github.com/goharbor/harbor.git

Kubernetes

v1.29.2

2024-02-14

https://github.com/kubernetes/kubernetes.git

Longhorn

v1.6.0

2024-02-01

https://github.com/longhorn/longhorn.git

Rancher

v2.8.2

2024-02-05

https://github.com/rancher/rancher.git

Rke2

v1.29.2+rke2r1

2024-02-23

https://github.com/rancher/rke2.git

Tekton-Catlin

2024-01-22

https://github.com/tektoncd/catlin.git

Tekton-Chains

v0.20.0

2024-01-30

https://github.com/tektoncd/chains.git

Tekton-Hub

v1.16.0

2024-02-01

https://github.com/tektoncd/hub.git

Tekton-Operator

v0.70.0

2024-02-20

https://github.com/tektoncd/operator.git

Tekton-Pipeline

v0.57.0

2024-02-18

https://github.com/tektoncd/pipeline.git

Tekton-Results

v0.9.1

2024-02-01

https://github.com/tektoncd/results.git

Uptime-Kuma

1.23.11

2023-12-31

https://github.com/louislam/uptime-kuma.git

JSON Config (repos.json)
{
  "Ansible": "https://github.com/ansible/ansible.git",
  "Argo-Events": "https://github.com/argoproj/argo-events.git",
  "Argo-Rollout": "https://github.com/argoproj/argo-rollouts.git",
  "Argo-Workflows": "https://github.com/argoproj/argo-workflows.git",
  "ArgoCD": "https://github.com/argoproj/argo-cd.git",
  "Asciidoctor": "https://github.com/asciidoctor/asciidoctor.git",
  "AWX": "https://github.com/ansible/awx.git",
  "Fleet": "https://github.com/rancher/fleet.git",
  "Gitlab": "https://gitlab.com/gitlab-org/gitlab-foss.git",
  "Gitlab-runner": "https://gitlab.com/gitlab-org/gitlab-runner.git",
  "Harbor": "https://github.com/goharbor/harbor.git",
  "Kubernetes": "https://github.com/kubernetes/kubernetes.git",
  "Longhorn": "https://github.com/longhorn/longhorn.git",
  "Rancher": "https://github.com/rancher/rancher.git",
  "Rke2": "https://github.com/rancher/rke2.git",
  "Uptime-Kuma": "https://github.com/louislam/uptime-kuma.git",
  "Gitlab-docker": "https://github.com/zengxs/gitlab-docker.git",
  "Tekton-Pipeline": "https://github.com/tektoncd/pipeline.git",
  "Tekton-Operator": "https://github.com/tektoncd/operator.git",
  "Tekton-Results": "https://github.com/tektoncd/results.git",
  "Tekton-Chains": "https://github.com/tektoncd/chains.git",
  "Tekton-Hub": "https://github.com/tektoncd/hub.git",
  "Tekton-Catlin": "https://github.com/tektoncd/catlin.git"
}
Python Code
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
import json
import os
import subprocess
import concurrent.futures
import sys

# Pfad zur JSON-Datei
json_file_path = 'repos.json'

# Funktion zum Einlesen der Repositories aus einer JSON-Datei
def read_repositories_from_json(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        repositories = json.load(file)
    return repositories

# Funktion zum Klonen/Aktualisieren und Ermitteln der neuesten Version und des Commit-Datums
def clone_update_get_latest_version(software_name, repo_url):
    local_dir = f"./repos/{software_name}"  # Dynamischer lokaler Pfad basierend auf Softwarename

    # Klonen oder aktualisieren des Repositories
    if not os.path.exists(local_dir):
        os.makedirs(local_dir, exist_ok=True)
        subprocess.run(["git", "clone", "--bare", repo_url, local_dir], check=True)
    else:
        subprocess.run(["git", "-C", local_dir, "fetch"], check=True)

    # Ermitteln der neuesten Version und des Commit-Datums
    command = f"git -C {local_dir} -c 'versionsort.suffix=-' ls-remote --exit-code --refs --sort='version:refname' --tags '{repo_url}' '*.*.*' | grep -v '-' | grep -iv 'rc' | tail --lines=1"
    result = subprocess.run(command, shell=True, check=True, stdout=subprocess.PIPE)
    latest_tag = result.stdout.decode('utf-8').strip().split('/')[-1]

    # Ermitteln des Commit-Datums für das neueste Tag
    commit_date_command = f"git -C {local_dir} log -1 --format=%as {latest_tag}"
    commit_date_result = subprocess.run(commit_date_command, shell=True, check=True, stdout=subprocess.PIPE)
    commit_date = commit_date_result.stdout.decode('utf-8').strip()

    return {
        "Softwarename": software_name,
        "Version": latest_tag,
        "Commit Datum": commit_date,
        "Repo URL": repo_url,
        "Lokaler Pfad": local_dir
    }

# Funktion zum Speichern der Ergebnisse als AsciiDoctor-Datei
def save_results_as_asciidoc(results, filename='results.adoc'):
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(f"[%header,format=csv]\n")
        file.write(f"|===\n")
        file.write(f"Softwarename,Version,Commit Datum\n")
        for result in results:
            file.write(f"{result['Softwarename']},{result['Version']},{result['Commit Datum']}\n")
        file.write(f"|===\n")

# Repositories aus der JSON-Datei einlesen
repositories = read_repositories_from_json(json_file_path)

# Multi-Threading für das Klonen/Aktualisieren und Ermitteln
results = []
with concurrent.futures.ThreadPoolExecutor() as executor:
    future_to_repo = {executor.submit(clone_update_get_latest_version, name, repo_url): name for name, repo_url in repositories.items()}
    for future in concurrent.futures.as_completed(future_to_repo):
        result = future.result()
        if result:
            results.append(result)

# Ergebnisse sortieren und ausgeben
sorted_results = sorted(results, key=lambda x: x['Softwarename'], reverse=False)

# Save as asciidoc
save_results_as_asciidoc(sorted_results)

print("\nErgebnisse:")
print(f"{'Softwarename':<20}{'Version':<20}{'Commit Datum':<20}{'Repo URL':<50}{'Lokaler Pfad'}")
for result in sorted_results:
    print(f"{result['Softwarename']:<20}{result['Version']:<20}{result['Commit Datum']:<20}{result['Repo URL']:<50}{result['Lokaler Pfad']}")

78. Other versions of this document