# Kubernetes Pod erstellen

Die Konfiguration von Kubernetes Pods erfolgt **imperativ, deklarativ oder mithilfe von API-Schnittstellen**. Dabei können Sie auch zusätzliche Ressourcen für die enthaltenen Container angeben und anpassen.

## Kubernetes Pod erstellen – das sind die Voraussetzungen

Um einen [Kubernetes Pod](https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-pod/) auszuführen, benötigen Sie ein laufendes **Kubernetes-Cluster**, entweder lokal auf einem Entwicklungssystem, in einer Cloud- oder On-Premises-Umgebung. Für die Installation empfehlen wir Ihnen hierzu das [Kubernetes-Tutorial](https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-tutorial/). Zudem sollte das kubectl-Befehlszeilentool auf dem Rechner vorhanden und eingerichtet sein, um die Interaktion mit dem Kubernetes-Cluster zu ermöglichen. Überprüfen Sie ebenfalls, ob die kubeconfig-Datei korrekt konfiguriert ist, um eine erfolgreiche Verbindung zum Cluster herzustellen.

Tipp [Managed Kubernetes](https://cloud.ionos.de/managed/kubernetes "Managed Kubernetes von IONOS") von IONOS gewährleistet die Hochverfügbarkeit Ihrer K8s-Deployments und optimiert gleichzeitig die Kosten. Die Integration in das IONOS Cloud-Ökosystem bietet zudem einen fortschrittlichen, vollständig integrierten persistenten Datenspeicher.

## Schritt-für-Schritt-Anleitung: Kubernetes Pod erstellen

Es gibt in Kubernetes drei Möglichkeiten, Pods zu erstellen:

1. Imperative Konfiguration
2. Deklarative Konfiguration
3. API-Schnittstelle verwenden

### Imperative Konfiguration

Beim imperativen Weg geben Sie dem System explizite Anweisungen über die `kubectl`-Befehlszeile, wie es einen Kubernetes Pod erstellen soll, ohne vorher eine detaillierte Konfigurationsdatei vorbereitet zu haben.

```shell
kubectl run nginx --image=nginx --restart=Never
```

Dieser Befehl erstellt einen einzelnen Pod mit dem Namen **nginx**, der den Nginx-Webserver enthält.

Da der imperative Weg Änderungen direkt vornimmt, ohne dass eine klare Definition des beabsichtigten Zustands vorhanden ist, wird im Allgemeinen der deklarative Ansatz empfohlen.

### Deklarative Konfiguration

Der deklarative Ansatz in Kubernetes erfordert die Definition des gewünschten Zustands der Ressourcen mithilfe von **YAML-Konfigurationsdateien**.

Öffnen Sie einen Texteditor und erstellen Sie eine YAML-Datei, zum Beispiel `nginx-pod.yaml`, die den gewünschten Zustand des Nginx-Pods beschreibt.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
    name: nginx-deployment
spec:
    selector:
        matchLabels:
            app: nginx
    minReadySeconds: 5
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
            - name: nginx-container
                image: nginx:latest
                ports:
                - containerPort: 80
```

Verwenden Sie den Befehl `kubectl apply`, um den Kubernetes Pod basierend auf der deklarativen Konfiguration zu aktivieren.

```shell
kubectl apply -f nginx-pod.yaml
```

Die deklarativen Konfigurationen, die Sie in den YAML-Dateien angeben, sind eine konkrete Aufzeichnung des **beabsichtigten Zustands**, einschließlich der Version des zu erstellenden Pods. Dies führt zur transparenten Verwaltung und Überwachung von Ressourcen in Ihrem Kubernetes-Cluster.

### API-Schnittstelle verwenden

Kubernetes bietet eine **RESTful-API**, über die Sie mit dem Kubernetes-Cluster interagieren können. Bevor Sie die API verwenden, müssen Sie sich authentifizieren und autorisieren. Dies erfolgt normalerweise durch Bereitstellung von Zugriffstoken oder Zertifikaten, je nach Konfiguration des Kubernetes-Clusters.

Hier ist ein Beispiel, wie Sie mit der REST-API eine **JSON-Datei** für einen Nginx-Pod erstellen.

```shell
cat > nginx-pod.json <<EOF
{
    "apiVersion": "apps/v1",
    "kind": "Deployment",
    "metadata": {
        "name": "nginx-deployment"
    },
    "spec": {
        "selector": {
            "matchLabels": {
                "app": "nginx"
            }
        },
        "minReadySeconds": 5,
        "template": {
            "metadata": {
                "labels": {
                    "app": "nginx"
                }
            },
            "spec": {
                "containers": [
                    {
                        "name": "nginx-container",
                        "image": "nginx:latest",
                        "ports": [
                            {
                                "containerPort": 80
                            }
                        ]
                    }
                ]
            }
        }
    }
}
EOF
```

Zum Aktivieren des Kubernetes Pods nutzen Sie `curl`, um mit der REST-API des Kubernetes-Clusters zu kommunizieren:

```shell
curl -k -v -X POST -H "Authorization: Bearer <JWT_TOKEN>" -H "Content-Type: application/json" https://cluster-ip:6443/api/v1/namespaces/default/pods -d@nginx-pod.json
```

Dieser `curl`-Befehl sendet eine **HTTPS-POST-Anfrage** an einen Kubernetes-Cluster-Endpunkt. Die Optionen `-k` und `-v` stehen für das Ignorieren der SSL-Zertifikatüberprüfung und den Verbose-Modus. Mit `-X` POST wird eine POST-Anfrage definiert. Der Header **Authorization** enthält ein Bearer-Token (ersetzen Sie `<JWT_TOKEN>` durch das tatsächliche Token), und Content-Type gibt den Datenformattyp als JSON an. Die Option `-d@nginx-pod.json` sendet die Daten an den Server.

## Pods ansehen

Um den aktuellen Status aller Pods im **Namespace** zu überprüfen, geben Sie folgenden Befehl ein:

```shell
kubectl get pods
```

Das Ergebnis ist eine Liste der vorhandenen Pods und ihrem Status, Startzeitpunkt und weiteren Details.

Detailliertere Informationen erhalten Sie mit:

```shell
kubectl describe pod my-pod
```

Dieser Befehl gibt ausführliche Angaben über den Pod zurück, einschließlich der Konfiguration, Ereignisse und Zustandsübergänge.

So zeigen Sie die **Protokolle** des Hauptcontainers im Kubernetes Pod an:

```shell
kubectl logs my-pod
```

Bei mehreren Containern können Sie den Container mit der Option `-c` kennzeichnen.

## Einen Pod löschen

Das Löschen von Pods ist unkompliziert und kann mit einem einfachen Befehl ausgeführt werden.

```shell
kubectl delete pod nginx
```

Dadurch wird der ausgewählte Kubernetes Pod gestoppt, und der zugehörige Container wird heruntergefahren. Im Beispiel haben wir den Nginx-Pod erfolgreich aus dem Cluster entfernt.


This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-pod-erstellen/](https://www.ionos.at/digitalguide/server/konfiguration/kubernetes-pod-erstellen/) for AI/LLM consumption.