Schnellstart: Bereitstellen eines Azure Linux mit OS Guard (Vorschau) AKS-Cluster mithilfe einer ARM-Vorlage

Führen Sie erste Schritte mit dem Azure Linux-Containerhost mithilfe einer ARM-Vorlage (Azure Resource Manager) aus, um einen Azure Linux-Containerhostcluster bereitzustellen. Nach der Installation der erforderlichen Komponenten installieren Sie die aks-preview Azure CLI-Erweiterung, registrieren Sie das Featurekennzeichen "AzureLinuxOSGuardPreview", erstellen Sie ein SSH-Schlüsselpaar, überprüfen Sie die Vorlage, stellen Sie die Vorlage bereit und validieren Sie sie, und stellen Sie dann eine Anwendung bereit.

Eine Azure Resource Manager-Vorlage ist eine JSON (JavaScript Object Notation)-Datei, welche die Infrastruktur und die Konfiguration für Ihr Projekt definiert. Die Vorlage verwendet eine deklarative Syntax. Sie beschreiben Ihre geplante Bereitstellung, ohne die Abfolge der Programmierbefehle zu schreiben, mit denen die Bereitstellung erstellt wird.

Überlegungen und Einschränkungen

Bevor Sie beginnen, lesen Sie die folgenden Überlegungen und Einschränkungen für Azure Linux mit OS Guard (Vorschau):

Kubernetes Version 1.32.0 oder höher ist für Azure Linux mit OS Guard erforderlich.
Alle Azure Linux mit OS Guard-Images haben Federal Information Process Standard (FIPS) und Vertrauenswürdiger Start aktiviert.
Azure CLI und ARM-Vorlagen sind die einzigen unterstützten Bereitstellungsmethoden für Azure Linux mit OS Guard auf AKS in Preview. PowerShell und Terraform werden nicht unterstützt.
Arm64-Images werden mit Azure Linux mit OS Guard auf AKS in der Preview nicht unterstützt.
NodeImage und None sind die einzigen unterstützten Betriebssystemupgradekanäle für Azure Linux mit OS Guard auf AKS. Unmanaged und SecurityPatch sind aufgrund des unveränderlichen /usr-Verzeichnisses nicht mit Azure Linux mit OS Guard kompatibel.
Artefaktstreaming wird nicht unterstützt.
Pod Sandboxing wird nicht unterstützt.
Vertrauliche virtuelle Computer (CVMs) werden nicht unterstützt.
Virtuelle Computer der Generation 1 (VMs) werden nicht unterstützt.

Voraussetzungen

Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.
Verwenden Sie die Bash-Umgebung in Azure Cloud Shell. Weitere Informationen finden Sie unter Azure Cloud Shell-Schnellstart: Bash.
Wenn Sie CLI-Referenzbefehle lieber lokal ausführen möchten, installieren Sie die Azure CLI. Wenn Sie mit Windows oder macOS arbeiten, sollten Sie die Azure CLI in einem Docker-Container ausführen. Weitere Informationen finden Sie unter Ausführen der Azure CLI in einem Docker-Container.
- Wenn Sie eine lokale Installation verwenden, melden Sie sich mithilfe des Befehls az login bei der Azure CLI an. Um den Authentifizierungsprozess abzuschließen, führen Sie die schritte aus, die in Ihrem Terminal angezeigt werden. Informationen zu anderen Anmeldeoptionen finden Sie unter Anmelden mit der Azure CLI.
- Wenn Sie dazu aufgefordert werden, installieren Sie die Azure CLI-Erweiterung bei der ersten Verwendung. Weitere Informationen zu Erweiterungen finden Sie unter Verwenden von Erweiterungen mit der Azure CLI.
- Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um auf die neueste Version zu aktualisieren.
Falls kubectl nicht bereits installiert ist, installieren Sie das Tool mithilfe von az aks install-cli über die Azure CLI, oder befolgen Sie die Upstream-Anweisungen.
Um einen AKS-Cluster mithilfe einer Resource Manager-Vorlage zu erstellen, geben Sie einen öffentlichen SSH-Schlüssel an. Wenn Sie diese Ressource benötigen, finden Sie im folgenden Abschnitt Informationen, andernfalls fahren Sie mit dem Abschnitt Überprüfen der Vorlage fort.
Die Identität, die Sie zum Erstellen Ihres Clusters verwenden, verfügt über die erforderlichen Mindestberechtigungen. Weitere Informationen zu Zugriff und Identität für AKS finden Sie unter Zugriffs- und Identitätsoptionen für Azure Kubernetes Service (AKS).
Zum Bereitstellen einer Bicep-Datei oder ARM-Vorlage benötigen Sie Schreibzugriff auf die Ressourcen, die Sie bereitstellen, und Zugriff auf alle Vorgänge für den Ressourcentyp Microsoft.Resources/deployments. Um beispielsweise eine virtuelle Maschine bereitzustellen, benötigen Sie die Berechtigungen Microsoft.Compute/virtualMachines/write und Microsoft.Resources/deployments/*. Eine Liste der Rollen und Berechtigungen finden Sie in den integrierten Azure-Rollen.

Installieren der Azure CLI-Erweiterung „aks-preview“

Von Bedeutung

AKS-Vorschaufunktionen sind auf Selbstbedienungsbasis und freiwillig verfügbar. Vorschauversionen werden „im Istzustand“ und „wie verfügbar“ bereitgestellt und sind von den Service Level Agreements und der eingeschränkten Garantie ausgeschlossen. AKS-Vorschauversionen werden teilweise vom Kundensupport auf Grundlage der bestmöglichen Leistung abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen. Weitere Informationen finden Sie in den folgenden Supportartikeln:

Führen Sie den folgenden Befehl aus, um die Erweiterung „aks-preview“ zu installieren:

az extension add --name aks-preview

Führen Sie den folgenden Befehl aus, um ein Update auf die neueste veröffentlichte Version der Erweiterung durchzuführen:

az extension update --name aks-preview

Registrieren des Feature-Flags "AzureLinuxOSGuardPreview"

Registrieren Sie das AzureLinuxOSGuardPreview Feature-Flag mithilfe des Befehls [az feature register][az-feature-register] wie im folgenden Beispiel gezeigt:

az feature register --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"

Es dauert einige Minuten, bis der Status Registered (Registriert) angezeigt wird. Überprüfen Sie den Registrierungsstatus mithilfe des Befehls [az feature show][az-feature-show]:

az feature show --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"

Wenn der Status "Registriert" widerspiegelt, aktualisieren Sie die Registrierung des Microsoft.ContainerService-Ressourcenanbieters mithilfe des Befehls [az provider register][az-provider-register]:

az provider register --namespace "Microsoft.ContainerService"

Erstellen eines SSH-Schlüsselpaars

Für den Zugriff auf AKS-Knoten stellen Sie eine Verbindung mithilfe eines SSH-Schlüsselpaars (öffentlich und privat) her, das Sie mithilfe des Befehls ssh-keygen generieren. Diese Dateien werden standardmäßig im Verzeichnis ~/.ssh erstellt. Durch die Ausführung des Befehls ssh-keygen wird jedes SSH-Schlüsselpaar mit dem gleichen Namen überschrieben, das bereits am angegebenen Speicherort vorhanden ist.

Navigieren Sie zu https://shell.azure.com, um Cloud Shell in Ihrem Browser zu öffnen.
Führen Sie den Befehl ssh-keygen aus. Das folgende Beispiel erstellt ein SSH-Schlüsselpaar mittels RSA-Verschlüsselung und einer Bitlänge von 4096:
```
ssh-keygen -t rsa -b 4096
```

Weitere Informationen zum Erstellen von SSH-Schlüsseln finden Sie unter Erstellen und Verwalten von SSH-Schlüsseln für die Authentifizierung in Azure.

Überprüfen der Vorlage

Die folgende Bereitstellung verwendet eine ARM-Vorlage aus den Azure-Schnellstartvorlagen.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.1",
    "parameters": {
        "clusterName": {
            "defaultValue": "osguardakscluster",
            "type": "String",
            "metadata": {
                "description": "The name of the Managed Cluster resource."
            }
        },
        "location": {
            "defaultValue": "[resourceGroup().location]",
            "type": "String",
            "metadata": {
                "description": "The location of the Managed Cluster resource."
            }
        },
        "dnsPrefix": {
            "type": "String",
            "metadata": {
                "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
            }
        },
        "agentCount": {
            "defaultValue": 3,
            "minValue": 1,
            "maxValue": 50,
            "type": "Int",
            "metadata": {
                "description": "The number of nodes for the cluster."
            }
        },
        "agentVMSize": {
            "defaultValue": "Standard_DS2_v2",
            "type": "String",
            "metadata": {
                "description": "The size of the Virtual Machine."
            }
        },
        "osSKU": {
            "defaultValue": "AzureLinuxOSGuard",
            "allowedValues": [
                "AzureLinuxOSGuard",
                "AzureLinux3OSGuard"
            ],
            "type": "String",
            "metadata": {
                "description": "The Linux SKU to use."
            }
        }
    },
    "resources": [
        {
            "type": "Microsoft.ContainerService/managedClusters",
            "apiVersion": "2025-05-01",
            "name": "[parameters('clusterName')]",
            "location": "[parameters('location')]",
            "identity": {
                "type": "SystemAssigned"
            },
            "properties": {
                "dnsPrefix": "[parameters('dnsPrefix')]",
                "agentPoolProfiles": [
                    {
                        "name": "agentpool",
                        "mode": "System",
                        "count": "[parameters('agentCount')]",
                        "vmSize": "[parameters('agentVMSize')]",
                        "osType": "Linux",
                        "osSKU": "[parameters('osSKU')]",
                        "osDiskType": "Managed",
                        "enableFIPS": true,
                        "securityProfile": {
                            "enableSecureBoot": true,
                            "enableVTPM": true
                        },
                    }
                ]
            }
        }
    ],
    "outputs": {
        "controlPlaneFQDN": {
            "type": "String",
            "value": "[reference(parameters('clusterName')).fqdn]"
        }
    }
}

Um Azure Linux mit OS Guard zu einer vorhandenen ARM-Vorlage hinzuzufügen, müssen Sie Folgendes hinzufügen:

"osSKU": "AzureLinuxOSGuard"
"mode": "System" bis agentPoolProfiles
"osDiskType": "Managed" bis agentPoolProfiles
"enableFIPS": true bis agentPoolProfiles
"securityProfile": {enableSecureBoot: true enableVTPM: true} bis agentPoolProfiles
legen Sie die apiVersion auf 2025-05-01 oder höher ("apiVersion": "2025-05-01") fest.

Implementieren der Vorlage

Wählen Sie die folgende Schaltfläche, um sich bei Azure anzumelden und eine Vorlage zu öffnen:
Wählen Sie die folgenden Werte aus, bzw. geben Sie sie ein.

Im Rahmen dieser Schnellstartanleitung behalten Sie die Standardwerte für Betriebssystem-Datenträgergröße (GB) , Agent-Anzahl, Größe der Agent-VM, Betriebssystemtyp, und Kubernetes-Version bei. Geben Sie Ihre eigenen Werte für die folgenden Vorlagenparameter an:
- Abonnement: Wählen Sie ein Azure-Abonnement aus.
- Ressourcengruppe: Wählen Sie Neu erstellen. Geben Sie einen eindeutigen Namen für die Ressourcengruppe ein, z. B. testAzureLinuxOSGuardResourceGroup, und wählen Sie dann "OK" aus.
- Standort: Wählen Sie einen Ort aus, z. B. USA, Osten.
- Clustername: Geben Sie einen eindeutigen Namen für den AKS-Cluster ein, z. B. testAzureLinuxOSGuardCluster.
- DNS-Präfix: Geben Sie ein eindeutiges DNS-Präfix für Ihren Cluster ein, z. B. myAzureLinuxOSGuardCluster.
- Benutzername des Linux-Administrators: Geben Sie einen Benutzernamen ein, um mithilfe von SSH eine Verbindung herzustellen, z. B. azureUser.
- SSH RSA Public Key: Kopieren und einfügen Sie den öffentlichen Teil Ihres SSH-Schlüsselpaars (standardmäßig den Inhalt von ~/.ssh/id_rsa.pub).
Wählen Sie Überprüfen + Erstellen aus.

Es dauert ein paar Minuten, um das Azure Linux mit OS Guard-Cluster zu erstellen. Warten Sie, bis der Cluster erfolgreich bereitgestellt wurde, bevor Sie mit dem nächsten Schritt fortfahren.

Validierung der Bereitstellung

Herstellen einer Verbindung mit dem Cluster

Um einen Kubernetes-Cluster zu verwalten, verwenden Sie den Kubernetes-Befehlszeilenclient kubectl.

Verwenden Sie für die lokale Installation von kubectl den Befehl az aks install-cli:
```
az aks install-cli
```
Mit dem Befehl kubectl können Sie az aks get-credentials für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.
```
az aks get-credentials --resource-group testAzureLinuxOSGuardResourceGroup --name testAzureLinuxCluster
```
Überprüfen Sie die Verbindung mit dem Cluster mithilfe des Befehls kubectl get. Dieser Befehl gibt eine Liste der Clusterknoten zurück.
```
kubectl get nodes
```
Das folgende Ausgabebeispiel zeigt die drei Knoten, die in den vorherigen Schritten erstellt wurden. Stellen Sie sicher, dass der Knotenstatus Bereit lautet:
```
NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-41324942-0   Ready    agent   6m44s   v1.12.6
aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6
```

Stellen Sie die Anwendung bereit

Eine Kubernetes-Manifestdatei definiert den gewünschten Zustand (Desired State) eines Clusters – also beispielsweise, welche Containerimages ausgeführt werden sollen.

In dieser Schnellstartanleitung verwenden Sie ein Manifest, um alle Objekte zu erstellen, die zum Ausführen der Azure Vote-Anwendung benötigt werden. Dieses Manifest umfasst zwei Kubernetes-Bereitstellungen:

Die Azure Vote-Python-Beispielanwendungen
Eine Redis-Instanz

Darüber hinaus werden zwei Kubernetes-Dienste erstellt:

Ein interner Dienst für die Redis-Instanz
Ein externer Dienst für den Zugriff auf die Azure Vote-Anwendung über das Internet

Erstellen Sie eine Datei mit dem Namen azure-vote.yaml.
- Bei Verwendung von Azure Cloud Shell kann diese Datei mit code, vi oder nano erstellt werden – genau wie bei der Verwendung eines virtuellen oder physischen Systems.

Fügen Sie die folgende YAML-Definition ein:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-vote-back
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-vote-back
  template:
    metadata:
      labels:
        app: azure-vote-back
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-back
        image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
        env:
        - name: ALLOW_EMPTY_PASSWORD
          value: "yes"
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 6379
          name: redis
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-back
spec:
  ports:
  - port: 6379
  selector:
    app: azure-vote-back
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: azure-vote-front
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-vote-front
  template:
    metadata:
      labels:
        app: azure-vote-front
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: azure-vote-front
        image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 80
        env:
        - name: REDIS
          value: "azure-vote-back"
---
apiVersion: v1
kind: Service
metadata:
  name: azure-vote-front
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: azure-vote-front

Eine Aufschlüsselung der YAML-Manifestdateien finden Sie unter Bereitstellungen und YAML-Manifeste.

Stellen Sie die Anwendung über den Befehl kubectl apply bereit, und geben Sie den Namen Ihres YAML-Manifests an:
```
kubectl apply -f azure-vote.yaml
```
Das folgende Beispiel ähnelt der Ausgabe, die die erfolgreich erstellten Bereitstellungen und Dienste anzeigt:
```
deployment "azure-vote-back" created
service "azure-vote-back" created
deployment "azure-vote-front" created
service "azure-vote-front" created
```

Testen der App

Wenn die Anwendung ausgeführt wird, macht ein Kubernetes-Dienst das Anwendungs-Front-End im Internet verfügbar. Dieser Vorgang kann einige Minuten dauern.

Verwenden Sie zum Überwachen des Fortschritts den Befehl kubectl get service mit dem Argument --watch:

kubectl get service azure-vote-front --watch

Die Ausgabe von EXTERNAL-IP für den azure-vote-front-Dienst lautet zu Beginn pending.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Nachdem die externe IP-Adresse (EXTERNAL-IP) von ausstehend in eine tatsächliche öffentliche IP-Adresse geändert wurde, verwenden Sie CTRL-C, um die kubectl-Überwachung zu beenden. Die folgende Beispielausgabe zeigt eine gültige öffentliche IP-Adresse, die dem Dienst zugewiesen ist:

azure-vote-front   LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Öffnen Sie die externe IP-Adresse Ihres Diensts in einem Webbrowser, um die Azure-Abstimmungs-App in Aktion zu sehen.

Screenshot der Navigation zur Azure Vote-Beispielanwendung.

Löschen des Clusters

Wenn Sie nicht mit den folgenden Tutorials fortfahren möchten, bereinigen Sie nicht benötigte Ressourcen, um Azure-Gebühren zu vermeiden. Verwenden Sie den Befehl az group delete, um die Ressourcengruppe und alle zugeordneten Ressourcen zu entfernen.

az group delete --name testAzureLinuxOSGuardCluster --yes --no-wait

Nächste Schritte

In dieser Schnellstartanleitung haben Sie ein Azure Linux mit OS Guard-Cluster bereitgestellt. Wenn Sie mehr über Azure Linux mit OS Guard erfahren und ein vollständiges Clusterbereitstellungs- und Verwaltungsbeispiel durchlaufen möchten, fahren Sie mit dem Lernprogramm für Azure Linux mit OS Guard fort.

Lernprogramm für Azure Linux OS Guard

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-05