Deployment und Service in Kubernetes: Ein praktischer Leitfaden

CI/CD (Continuous Integration/Continuous Deployment) hat sich als unverzichtbare Praxis für die moderne Softwareentwicklung etabliert. Mit der wachsenden Beliebtheit von Kubernetes als Containerorchestrierungstool ist es sinnvoll, sich mit den Grundlagen von CI/CD in einer Kubernetes-Umgebung vertraut zu machen.

In diesem Tutorial zeigen wir Ihnen, wie Sie Kubernetes Deployments und Services erstellen, um Ihre Anwendungen in einer Kubernetes-Umgebung auszuführen und sie für den Zugriff von außen verfügbar zu machen. Diese Grundlagen bilden eine solide Basis für den Aufbau einer CI/CD-Umgebung auf Kubernetes, die wir in zukünftigen Artikeln genauer betrachten werden.

Schritt 1: Building Container Images mit Docker und Buildah

# Docker: Ein Dockerfile erstellen und ein Image erstellen

mkdir demo

cd demo

nano Dockerfile

# Fügen Sie den Dockerfile-Inhalt hinzu

sudo docker image build -t nkhare/nginx:latest .

# Buildah: Buildah-Installation und Image-Erstellung

cd

mkdir ~/buildah

cd ~/buildah

export GOPATH=`pwd`

git clone https://github.com/containers/buildah ./src/github.com/containers/buildah

cd ./src/github.com/containers/buildah

make runc all TAGS=“apparmor seccomp“

sudo cp ~/buildah/src/github.com/opencontainers/runc/runc /usr/bin/.

sudo apt install buildah

sudo buildah build-using-dockerfile -t rsvpapp:buildah github.com/do-community/rsvpapp-webinar1

Schritt 2: Einrichten eines Kubernetes-Clusters auf centron mit kubeadm und Terraform

# Einrichten des Clusters mit Terraform und kubeadm

ssh-keygen -t rsa

cd k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/

./script.sh

kubectl get nodes

Schritt 3: Erstellen von Container-Images mit Kaniko

# Erstellen von Container-Images mit Kaniko

sudo kubectl create configmap docker-config –from-file=$HOME/.docker/config.json

nano pod-kaniko.yml

# Fügen Sie den Pod-Definitionsinhalt hinzu

kubectl apply -f pod-kaniko.yml

kubectl get pods

Schritt 4: Kubernetes Deployments erstellen

Kubernetes Deployments ermöglichen es Ihnen, Ihre Anwendungen auszuführen und definieren den gewünschten Zustand für Ihre Pods. In diesem Schritt erstellen wir eine Nginx-Deployment-Datei namens `deployment.yml` im Verzeichnis `~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terraform/`, um ein Nginx Deployment zu erstellen.

1. Öffnen Sie zuerst die Datei:

 nano deployment.yml

2. Fügen Sie die folgende Konfiguration hinzu, um Ihr Nginx Deployment zu definieren:

 apiVersion: apps/v1

kind: Deployment

metadata:

name: nginx-deployment

labels:

app: nginx

spec:

replicas: 3

selector:

matchLabels:

app: nginx

template:

metadata:

labels:

app: nginx

spec:

containers:

– name: nginx

image: nginx:1.7.9

ports:

– containerPort: 80

3. Deployen Sie das Deployment mit dem folgenden Befehl:

 kubectl apply -f deployment.yml

Schritt 5: Kubernetes Services erstellen

Kubernetes Services ermöglichen es, Anwendungen intern und extern verfügbar zu machen. Jeder Service definiert einen `ServiceType`, der festlegt, wie der Service freigegeben wird. In diesem Beispiel verwenden wir einen `NodePort ServiceType`, der den Service auf einem statischen Port auf jedem Knoten freigibt.

1. Erstellen Sie eine Datei namens `service.yml` im Verzeichnis `~/k8s-cicd-webinars/webinar1/2-kubernetes/1-Terrafrom/`:

 nano service.yml

2. Fügen Sie den folgenden Inhalt hinzu, um Ihren Service zu definieren:

 kind: Service

apiVersion: v1

metadata:

name: nginx-service

spec:

selector:

app: nginx

type: NodePort

ports:

– protocol: TCP

port: 80

targetPort: 80

nodePort: 30111

3. Deployen Sie den Service mit dem folgenden Befehl:

 kubectl apply -f service.yml

Nachdem Sie diese Schritte ausgeführt haben, ist Ihr Nginx-Deployment nun bereit und über den erstellten Service auf Port 30111 sowohl intern als auch extern verfügbar. Deployment und Service in Kubernetes: Ein praktischer Leitfaden