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
