Übung: Bereitstellen einer Anwendung in Ihrem Azure Kubernetes Service-Cluster

10 Minuten

In dieser Übung stellen Sie die Website Ihres Unternehmens als Test-App in Azure Kubernetes Service (AKS) bereit. Die Website ist eine statische Website mit einem zugrunde liegenden Technologiestapel basierend auf HTML, CSS und JavaScript. Die Website empfängt nicht so viele Anforderungen wie die anderen Dienste und bietet eine sichere Möglichkeit zum Testen der Bereitstellungsoptionen.

Hinweis

Wenn Sie den Quellcode weiter untersuchen möchten, finden Sie den Code für die Web-App in diesem GitHub-Repository. Außerdem wird diese Beispiel-App nur in einem Linux-Knotenpool bereitgestellt.

Wichtig

Sie benötigen für diese Übung ein eigenes Azure-Abonnement. Außerdem fallen möglicherweise Gebühren für Sie an. Wenn Sie noch kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Erstellen eines Bereitstellungsmanifests

Sie erstellen eine Bereitstellungsmanifestdatei, um Ihre Anwendung bereitzustellen. Mithilfe der Manifestdatei können Sie definieren, welche Art von Ressource bereitgestellt werden soll. Außerdem lassen sich so alle Details im Zusammenhang mit der Workload definieren.

Kubernetes gruppiert Container in logische Strukturen namens Pods, die über keine Intelligenz verfügen. Bei Bereitstellungen wird die fehlende Intelligenz zum Erstellen Ihrer Anwendung hinzugefügt. Erstellen Sie nun eine Bereitstellungsdatei.

Melden Sie sich bei Azure Cloud Shell an.

Azure Cloud Shell
Erstellen Sie in Cloud Shell mithilfe des integrierten Editors eine Manifestdatei für die Kubernetes-Bereitstellung namens deployment.yaml.
```
touch deployment.yaml
```
Öffnen Sie den integrierten Editor in Cloud Shell, indem Sie code . eingeben.
Öffnen Sie die deployment.yaml-Datei, und fügen Sie den folgenden YAML-Codeabschnitt hinzu.
```
# deployment.yaml
apiVersion: apps/v1 # The API resource where this workload resides
kind: Deployment # The kind of workload we're creating
metadata:
  name: contoso-website # This will be the name of the deployment
```
In diesem Code haben Sie die ersten zwei Schlüssel hinzugefügt, um Kubernetes über die Eigenschaften apiVersion und kind des Manifests zu informieren, das Sie erstellen. Bei name handelt es sich um den Namen der Bereitstellung. Sie verwenden ihn zum Identifizieren und Abfragen der Bereitstellungsinformationen bei der Verwendung von kubectl.

Tipp

Weitere Informationen zu apiVersion und den Werten, die in diesen Schlüssel eingefügt werden müssen, finden Sie in der offiziellen Kubernetes-Dokumentation. Am Ende dieses Moduls finden Sie einen Link.
Eine Bereitstellung umschließt einen Pod. Sie verwenden eine Vorlagendefinition, um die Podinformationen in der Manifestdatei zu definieren. Die Vorlage wird in der Manifestdatei unterhalb des Abschnitts für die Bereitstellungsspezifikation platziert.

Aktualisieren Sie die deployment.yaml-Datei so, dass sie dem folgenden YAML-Code entspricht.
```
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
spec:
  template: # This is the template of the pod inside the deployment
    metadata: # Metadata for the pod
      labels:
        app: contoso-website
```
Pods verwenden nicht dieselben Namen wie die Bereitstellungen. Der Name des Pods ist eine Mischung aus dem Namen der Bereitstellung, wobei eine zufällige ID am Ende hinzugefügt wird.

Beachten Sie die Verwendung des Schlüssels labels. Sie fügen den Schlüssel labels hinzu, damit Bereitstellungen nach Pods suchen und diese gruppieren können.
Ein Pod umschließt mindestens einen Container. Alle Pods verfügen über einen Spezifikationsabschnitt, mit dem Sie die Container innerhalb dieses Pods definieren können.

Aktualisieren Sie die Datei deployment.yaml so, dass sie der folgenden YAML-Datei entspricht.
```
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
spec:
  template: # This is the template of the pod inside the deployment
    metadata:
      labels:
        app: contoso-website
    spec:
      containers: # Here we define all containers
        - name: contoso-website
```
Der Schlüssel containers ist ein Array von Containerspezifikationen, da ein Pod einen oder mehrere Container aufweisen kann. Die Spezifikation definiert Angaben wie image, name, resources und ports sowie andere wichtige Informationen zum Container.

Alle ausgeführten Pods erhalten den Namen contoso-website-<UUID>, wobei UUID eine generierte ID ist, sodass alle Ressourcen eindeutig identifiziert werden können.

Es empfiehlt sich, eine minimale und eine maximale Menge an Ressourcen zu definieren, die die App aus dem Cluster verwenden darf. Sie verwenden den Schlüssel resources, um diese Informationen anzugeben.

Aktualisieren Sie die deployment.yaml-Datei so, dass sie dem folgenden YAML-Code entspricht.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
spec:
  template: # This is the template of the pod inside the deployment
    metadata:
      labels:
        app: contoso-website
    spec:
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-website
          name: contoso-website
          resources:
            requests: # Minimum amount of resources requested
              cpu: 100m
              memory: 128Mi
            limits: # Maximum amount of resources requested
              cpu: 250m
              memory: 256Mi

Beachten Sie, wie es Ihnen der Ressourcenabschnitt ermöglicht, die minimale Menge an Ressourcen als Anforderung und die maximale Menge an Ressourcen als Limit anzugeben.

Der letzte Schritt besteht darin, die Ports zu definieren, die dieser Container über den Schlüssel ports extern verfügbar macht. Der Schlüssel ports ist ein Array von Objekten, was bedeutet, dass ein Container in einem Pod mehrere Ports mit mehreren Namen verfügbar machen kann.

Aktualisieren Sie die Datei deployment.yaml so, dass sie der folgenden YAML-Datei entspricht.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
spec:
  template: # This is the template of the pod inside the deployment
    metadata:
      labels:
        app: contoso-website
    spec:
      nodeSelector:
        kubernetes.io/os: linux
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-website
          name: contoso-website
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 80 # This container exposes port 80
              name: http # We named that port "http" so we can refer to it later

Beachten Sie, wie Sie den Port mithilfe des name-Schlüssels benennen. Das Benennen von Ports ermöglicht Ihnen das Ändern des verfügbar gemachten Ports, ohne dass Sie hierfür Dateien ändern müssen, die auf den Port verweisen.

Fügen Sie abschließend einen Auswahlbereich hinzu, um die Workloads zu definieren, die von der Bereitstellung verwaltet werden. Der selector-Schlüssel wird im Abschnitt für die Bereitstellungsspezifikation der Manifestdatei platziert. Verwenden Sie den matchLabels-Schlüssel, um die Bezeichnungen für alle Pods aufzulisten, die von der Bereitstellung verwaltet werden.

Aktualisieren Sie die Datei deployment.yaml so, dass sie der folgenden YAML-Datei entspricht.
```
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: contoso-website
spec:
  selector: # Define the wrapping strategy
    matchLabels: # Match all pods with the defined labels
      app: contoso-website # Labels follow the `name: value` template
  template: # This is the template of the pod inside the deployment
    metadata:
      labels:
        app: contoso-website
    spec:
      nodeSelector:
        kubernetes.io/os: linux
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-website
          name: contoso-website
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 80
              name: http
```
Hinweis

In einem AKS-Cluster mit mehreren Knotenpools (Linux und Windows) definiert diese oben aufgeführte Bereitstellungsmanifestdatei auch einen nodeSelector, um Ihren AKS-Cluster anzuweisen, den Pod der Beispielanwendung auf einem Knoten auszuführen, der Linux-Container ausführen kann.

Auf Linux-Knoten können keine Windows-Container ausgeführt werden (und umgekehrt).
Speichern Sie die Manifestdatei, und schließen Sie den Editor.

Anwenden des Manifests

Führen Sie in Cloud Shell den Befehl kubectl apply aus, um das Bereitstellungsmanifest an Ihren Cluster zu übermitteln.
```
kubectl apply -f ./deployment.yaml
```
Der Befehl sollte ein Ergebnis ausgeben, das dem folgenden Beispiel ähnelt.
```
deployment.apps/contoso-website created
```
Führen Sie den Befehl kubectl get deploy aus, um zu prüfen, ob die Bereitstellung erfolgreich war.
```
kubectl get deploy contoso-website
```
Der Befehl sollte eine Tabelle ausgeben, die dem folgenden Beispiel ähnelt.
```
NAME              READY   UP-TO-DATE   AVAILABLE   AGE
contoso-website   0/1     1            0           16s
```
Führen Sie den Befehl kubectl get pods aus, um zu überprüfen, ob der Pod ausgeführt wird.
```
kubectl get pods
```
Der Befehl sollte eine Tabelle ausgeben, die dem folgenden Beispiel ähnelt.
```
NAME                               READY   STATUS    RESTARTS   AGE
contoso-website-7c58c5f699-r79mv   1/1     Running   0          63s
```

Weiter

Erstellen eines Bereitstellungsmanifests

Anwenden des Manifests

Feedback