Kubernetes Erstellbefehl

Einführung

Der Befehl kubectl create ist ein essentielles Werkzeug zum Erstellen von Kubernetes-Ressourcen. Er verwendet YAML- oder JSON-Dateien, um Ressourcen wie Namespaces, Deployments, Services, Secrets und ConfigMaps zu definieren. In diesem Lab lernen Sie, wie Sie diese Ressourcen Schritt für Schritt erstellen und verstehen, welche Rolle sie in Kubernetes spielen.

Am Ende dieses Labs können Sie:

Ein Minikube-Cluster starten und überprüfen.
Verschiedene Kubernetes-Ressourcen mit kubectl create erstellen und überprüfen.

Minikube starten und Cluster überprüfen

Bevor Sie mit Kubernetes arbeiten können, benötigen Sie einen laufenden Cluster. Minikube bietet einen leichten lokalen Kubernetes-Cluster.

Navigieren Sie in Ihr Projektverzeichnis:

Öffnen Sie Ihr Terminal und navigieren Sie in das Standardarbeitsverzeichnis:
```
cd /home/labex/project
```
Starten Sie Minikube:

Starten Sie Minikube, um den Cluster zu initialisieren:
```
minikube start
```
- Minikube erstellt einen Kubernetes-Cluster mit einem einzigen Knoten. Dieser Schritt kann einige Minuten dauern.
Überprüfen Sie den Minikube-Status:

Prüfen Sie, ob Minikube erfolgreich gestartet wurde:
```
minikube status
```
Suchen Sie nach Komponenten wie apiserver und kubelet, die als Running aufgeführt sind.
Bestätigen Sie die Kubernetes-Konfiguration:

Stellen Sie sicher, dass kubectl mit dem Minikube-Cluster verbunden ist:
```
kubectl cluster-info
```
Dadurch werden Details über den API-Server und andere Komponenten angezeigt.

Wenn Minikube nicht startet, verwenden Sie minikube delete, um die Einstellungen zurückzusetzen und es erneut zu versuchen.

Den kubectl create-Befehl erkunden

Der Befehl kubectl create bietet mehrere Unterbefehle zum Erstellen von Kubernetes-Ressourcen. Er hilft bei der Verwaltung der Erstellung von Ressourcen wie Namespaces, Deployments, Services, Secrets und ConfigMaps.

Führen Sie den folgenden Befehl aus, um die verfügbaren Unterbefehle von kubectl create anzuzeigen:

kubectl create -h

Sie werden die folgende Ausgabe sehen:

Create a resource from a file or from stdin.

JSON and YAML formats are accepted.

Examples:
  ## Create a pod using the data in pod.json
  kubectl create -f./pod.json

  ## Create a pod based on the JSON passed into stdin
  cat pod.json | kubectl create -f -

  ## Edit the data in registry.yaml in JSON then create the resource using the edited data
  kubectl create -f registry.yaml --edit -o json

Available Commands:
  clusterrole           Create a cluster role
  clusterrolebinding    Create a cluster role binding for a particular cluster role
  configmap             Create a config map from a local file, directory or literal value
  cronjob               Create a cron job with the specified name
  deployment            Create a deployment with the specified name
  ingress               Create an ingress with the specified name
  job                   Create a job with the specified name
  namespace             Create a namespace with the specified name
  poddisruptionbudget   Create a pod disruption budget with the specified name
  priorityclass         Create a priority class with the specified name
  quota                 Create a quota with the specified name
  role                  Create a role with single rule
  rolebinding           Create a role binding for a particular role or cluster role
  secret                Create a secret using specified subcommand
  service               Create a service using a specified subcommand
  serviceaccount        Create a service account with the specified name
  token                 Request a service account token

Überprüfen Sie die verfügbaren Unterbefehle und ihre Beschreibungen, um zu verstehen, wie kubectl create verwendet werden kann.

Einen Namespace erstellen

Namespaces ermöglichen es Ihnen, Ressourcen in Kubernetes zu organisieren und voneinander zu isolieren.

Erstellen einer Namespace-Definitionsdatei:

Öffnen Sie eine neue Datei mit dem Namen namespace.yaml:
```
nano namespace.yaml
```
Definieren des Namespaces:

Fügen Sie den folgenden Inhalt hinzu:
```
apiVersion: v1
kind: Namespace
metadata:
  name: mynamespace
```
Speichern Sie die Datei, indem Sie Strg+X, dann Y und Enter drücken.
Anwenden des Namespaces:

Erstellen Sie den Namespace:
```
kubectl create -f namespace.yaml
```
Überprüfen des Namespaces:

Prüfen Sie die Liste der Namespaces:
```
kubectl get namespaces
```
Stellen Sie sicher, dass mynamespace in der Ausgabe erscheint.

Ein Deployment erstellen

Deployments verwalten und halten den gewünschten Zustand von Pods aufrecht.

Erstellen einer Deployment-Definitionsdatei:

Öffnen Sie eine Datei mit dem Namen deployment.yaml:
```
nano deployment.yaml
```

Definieren des Deployments:

Fügen Sie den folgenden Inhalt hinzu, um drei Replikate eines Nginx-Containers bereitzustellen:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mydeployment
  namespace: mynamespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: nginx-container
          image: nginx

Speichern Sie die Datei.

Anwenden des Deployments:

Erstellen Sie das Deployment:
```
kubectl create -f deployment.yaml
```
Überprüfen des Deployments:

Prüfen Sie das Deployment und seine Pods:
```
kubectl get deployments -n mynamespace
kubectl get pods -n mynamespace
```
Stellen Sie sicher, dass drei Pods ausgeführt werden.

Einen Service erstellen

Ein Service bietet stabilen Netzwerkzugang zu einer Gruppe von Pods.

Erstellen einer Service-Definitionsdatei:

Öffnen Sie eine Datei mit dem Namen service.yaml:
```
nano service.yaml
```

Definieren des Services:

Fügen Sie den folgenden Inhalt hinzu:

apiVersion: v1
kind: Service
metadata:
  name: myservice
  namespace: mynamespace
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Speichern Sie die Datei.

Anwenden des Services:

Erstellen Sie den Service:
```
kubectl create -f service.yaml
```
Überprüfen des Services:

Prüfen Sie die Liste der Services:
```
kubectl get services -n mynamespace
```
Stellen Sie sicher, dass myservice in der Liste aufgeführt ist.

Ein Secret erstellen

Secrets speichern sicher sensible Informationen wie Passwörter oder API-Schlüssel.

Erstellen einer Secret-Definitionsdatei:

Öffnen Sie eine Datei mit dem Namen secret.yaml:
```
nano secret.yaml
```

Definieren des Secrets:

Fügen Sie den folgenden Inhalt mit Base64-codierten Werten hinzu:

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
  namespace: mynamespace
type: Opaque
data:
  username: dXNlcm5hbWU= ## Base64 for "username"
  password: cGFzc3dvcmQ= ## Base64 for "password"

Speichern Sie die Datei.

Anwenden des Secrets:

Erstellen Sie das Secret:
```
kubectl create -f secret.yaml
```
Überprüfen des Secrets:

Prüfen Sie die Liste der Secrets:
```
kubectl get secrets -n mynamespace
```
Stellen Sie sicher, dass mysecret in der Ausgabe erscheint.

Eine ConfigMap erstellen

ConfigMaps speichern Konfigurationsdaten in Schlüssel-Wert-Paaren.

Erstellen einer ConfigMap-Definitionsdatei:

Öffnen Sie eine Datei mit dem Namen configmap.yaml:
```
nano configmap.yaml
```

Definieren der ConfigMap:

Fügen Sie den folgenden Inhalt hinzu:

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfigmap
  namespace: mynamespace
data:
  database.host: "example.com"
  database.port: "5432"

Speichern Sie die Datei.

Anwenden der ConfigMap:

Erstellen Sie die ConfigMap:
```
kubectl create -f configmap.yaml
```
Überprüfen der ConfigMap:

Prüfen Sie die Liste der ConfigMaps:
```
kubectl get configmaps -n mynamespace
```
Stellen Sie sicher, dass myconfigmap in der Ausgabe erscheint.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie:

Einen Minikube-Cluster starten und überprüfen.
Kubernetes-Ressourcen wie Namespaces, Deployments, Services, Secrets und ConfigMaps erstellen.
Den Status dieser Ressourcen überprüfen.

Durch das Beherrschen dieser Schritte können Sie Anwendungen effektiv in Kubernetes verwalten und bereitstellen. Üben Sie diese Schritte, um Ihr Verständnis zu festigen!