Isolieren von Workloads mit Namespaces

Einführung

Kubernetes bietet Namespaces (Namensräume) als Möglichkeit, Workloads und Ressourcen in einem Cluster voneinander zu isolieren. In diesem Lab lernen Sie, wie Sie Namespaces verwenden können, um Workloads und Ressourcen zu isolieren. Sie werden einen Namespace erstellen, eine einfache Webanwendung in diesem Namespace bereitstellen und überprüfen, dass die Webanwendung von den anderen Ressourcen im Cluster isoliert ist.

Starten Sie den Minikube-Cluster

Bevor Sie Ressourcen erstellen, benötigen Sie einen laufenden Kubernetes-Cluster. Minikube ist eine leichte Kubernetes-Umgebung, die auf Ihrem lokalen Rechner läuft.

Navigieren Sie in Ihr Arbeitsverzeichnis:

Öffnen Sie das Terminal und navigieren Sie in den Standard-Projektordner:
```
cd /home/labex/project
```
Starten Sie Minikube:

Starten Sie Minikube, um einen Kubernetes-Cluster zu initialisieren:
```
minikube start
```
- Dieser Befehl richtet einen Ein-Knoten-Kubernetes-Cluster auf Ihrem lokalen Rechner ein.
- Minikube kann je nach Leistung Ihres Systems einige Minuten dauern, um zu starten.
Überprüfen Sie, ob Minikube läuft:

Überprüfen Sie den Status des Minikube-Clusters:
```
minikube status
```
- Suchen Sie nach Komponenten wie kubelet und apiserver, die als Running (Läuft) aufgeführt sind.
- Wenn der Cluster nicht läuft, führen Sie minikube start erneut aus.

Wenn Sie Probleme beim Starten von Minikube haben, können Sie minikube delete verwenden, um die Umgebung bei Bedarf zurückzusetzen.

Erstellen Sie einen Namespace

In diesem Schritt erstellen Sie einen Namespace (Namensraum) namens webapp, um die Webanwendung von den anderen Ressourcen im Cluster zu isolieren.

Erstellen Sie eine Datei namens namespace.yaml mit folgendem Inhalt:

apiVersion: v1
kind: Namespace
metadata:
  name: webapp

Wenden Sie den Namespace auf Ihren Cluster mit folgendem Befehl an:

kubectl apply -f namespace.yaml

Überprüfen Sie, ob der Namespace erstellt wurde, mit folgendem Befehl:

kubectl get namespaces

Sie sollten den webapp-Namespace in der Liste der Namespaces sehen.

Bereitstellen einer Webanwendung

In diesem Schritt werden Sie eine einfache Webanwendung im webapp-Namespace (Namensraum) bereitstellen.

Erstellen Sie eine Datei namens web-app.yaml mit folgendem Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  namespace: webapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Diese Datei erstellt ein Deployment (Bereitstellung) mit einer Replik eines Containers, der die neueste Version des Nginx-Webservers ausführt.

Wenden Sie das Deployment auf Ihren Cluster mit folgendem Befehl an:

kubectl apply -f web-app.yaml

Überprüfen Sie, ob die Webanwendung im webapp-Namespace läuft, mit folgendem Befehl:

kubectl get pods -n webapp

Sie sollten den web-app-Pod in der Liste der Pods sehen, die im webapp-Namespace laufen.

Stellen Sie die Webanwendung zur Verfügung

In diesem Schritt werden Sie die Webanwendung für die Außenwelt mithilfe eines Kubernetes-Services (Dienstes) zugänglich machen.

Erstellen Sie eine Datei namens web-app-service.yaml mit folgendem Inhalt:

apiVersion: v1
kind: Service
metadata:
  name: web-app
  namespace: webapp
spec:
  selector:
    app: web-app
  ports:
    - name: http
      port: 80
      targetPort: 80
  type: ClusterIP

Diese Datei erstellt einen Service, der die Webanwendung im Cluster über eine ClusterIP zugänglich macht.

Wenden Sie den Service auf Ihren Cluster mit folgendem Befehl an:

kubectl apply -f web-app-service.yaml

Überprüfen Sie, ob der Service im webapp-Namespace (Namensraum) läuft, mit folgendem Befehl:

kubectl get services -n webapp

Sie sollten den web-app-Service in der Liste der Services sehen, die im webapp-Namespace laufen.

Überprüfen Sie die Namespace-Isolation

In diesem Schritt überprüfen Sie, ob die Webanwendung von den anderen Ressourcen im Cluster isoliert ist.

Erstellen Sie eine Datei namens other-app.yaml mit folgendem Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: other
spec:
  replicas: 1
  selector:
    matchLabels:
      app: other
  template:
    metadata:
      labels:
        app: other
    spec:
      containers:
        - name: nginx
          image: nginx
          ports:
            - containerPort: 80

In dieser Datei erstellen Sie ein weiteres Deployment namens other im Standard-Namespace (default namespace), das einen Container mit dem nginx-Image ausführt.

Wenden Sie das Deployment auf Ihren Cluster mit folgendem Befehl an:

kubectl apply -f other-app.yaml

Überprüfen Sie, ob das Deployment im Standard-Namespace läuft, mit folgendem Befehl:

kubectl get pods | grep other

Sie sollten den other-Pod in der Liste der Pods sehen, die im Standard-Namespace laufen.

Überprüfen des Zugriffs zwischen Namespaces

Zuerst ermitteln Sie den Namen des Pods, in dem Ihre Anwendung läuft, indem Sie den folgenden Befehl ausführen:

kubectl get pods -l app=other

Sie sollten den other Pod sehen. Notieren Sie sich den Namen des Pods.

Als Nächstes führen Sie den folgenden Befehl aus, um eine Shell-Sitzung in dem Container zu öffnen, in dem Ihre Anwendung läuft:

kubectl exec -it pod-name -- /bin/sh

Ersetzen Sie <pod-name> durch den Namen des Pods, den Sie sich zuvor notiert haben.

Sobald Sie sich in der Shell-Sitzung befinden, führen Sie den folgenden Befehl aus, um auf die web-app Deployment zuzugreifen:

curl web-app.webapp

Sie sollten die HTML-Antwort vom Nginx-Webserver sehen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Namespaces (Namensräume) verwenden können, um Workloads und Ressourcen in einem Kubernetes-Cluster zu isolieren. Sie haben einen Namespace erstellt, eine einfache Webanwendung in diesem Namespace bereitgestellt, die Webanwendung für die Außenwelt mithilfe eines Kubernetes-Services zugänglich gemacht und überprüft, ob die Webanwendung von den anderen Ressourcen im Cluster isoliert ist.