Szybki start: wdrażanie klastra Azure Kubernetes Service (AKS) z usługą Azure Linux z funkcją OS Guard (wersja zapoznawcza) przy użyciu interfejsu wiersza polecenia platformy Azure

Z tego przewodnika Szybki start dowiesz się, jak wykonywać następujące zadania:

Wymagania wstępne

• Jeśli nie masz jeszcze konta platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.

• Użyj środowiska Bash w Azure Cloud Shell. Aby uzyskać więcej informacji, zobacz Przewodnik Szybki start usługi Azure Cloud Shell — Bash.

  

• Jeśli wolisz uruchamiać polecenia referencyjne interfejsu wiersza polecenia lokalnie, instaluj Azure CLI. Jeśli korzystasz z systemu Windows lub macOS, rozważ uruchomienie Azure CLI w kontenerze Docker. Aby uzyskać więcej informacji, zobacz Jak uruchomić Azure CLI w kontenerze Docker.

  • Jeśli używasz instalacji lokalnej, zaloguj się do Azure CLI przy użyciu polecenia az login. Aby zakończyć proces uwierzytelniania, wykonaj kroki wyświetlane na Twoim terminalu. Aby uzyskać inne opcje logowania, zobacz Zaloguj się za pomocą Azure CLI.
  • Gdy zostaniesz o to poproszony/a, zainstaluj rozszerzenie Azure CLI przy pierwszym użyciu. Aby uzyskać więcej informacji na temat rozszerzeń, zobacz Korzystanie z rozszerzeń w interfejsie wiersza polecenia platformy Azure.
  • Uruchom az version, aby znaleźć zainstalowaną wersję i biblioteki zależne. Aby przeprowadzić uaktualnienie do najnowszej wersji, uruchom polecenie az upgrade.

Azure Linux — uwagi i ograniczenia dotyczące OS Guard

Przed rozpoczęciem zapoznaj się z następującymi zagadnieniami i ograniczeniami dotyczącymi platformy Azure dla systemu Linux z funkcją OS Guard (wersja zapoznawcza):

• Platforma Kubernetes w wersji 1.32.0 lub nowszej jest wymagana dla systemu Linux platformy Azure z funkcją OS Guard.
• Wszystkie obrazy systemu Azure Linux z OS Guard mają włączony standard Federal Information Processing Standard (FIPS) oraz Trusted Launch.
• Interfejs wiersza polecenia platformy Azure (Azure CLI) i szablony ARM są jedynymi obsługiwanymi metodami wdrażania dla Azure Linux z funkcją OS Guard w AKS w wersji preview. Program PowerShell i program Terraform nie są obsługiwane.
• Obrazy Arm64 nie są obsługiwane na platformie Azure Linux z funkcją OS Guard w usłudze AKS w wersji zapoznawczej.
• NodeImage i None są jedynymi obsługiwanymi kanałami aktualizacji systemu operacyjnego (OS) dla systemu Azure Linux z funkcją OS Guard w usłudze AKS. Unmanaged i SecurityPatch są niezgodne z systemem Linux platformy Azure z funkcją OS Guard ze względu na niezmienny katalog /usr.
• Przesyłanie strumieniowe artefaktów nie jest obsługiwane.
• Pod Sandboxing nie jest obsługiwany.
• Poufne maszyny wirtualne (CVM) nie są obsługiwane.
• Maszyny wirtualne 1. generacji nie są obsługiwane.

Zainstaluj rozszerzenie Azure CLI aks-preview

Zainstaluj rozszerzenie aks-preview przy użyciu polecenia az extension add.

az extension add --name aks-preview

Zaktualizuj aks-preview rozszerzenie do najnowszej wersji za pomocą polecenia az extension update.

az extension update --name aks-preview

Zarejestruj flagę funkcji AzureLinuxOSGuardPreview

1. Zarejestruj flagę funkcji AzureLinuxOSGuardPreview za pomocą polecenia az feature register.

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

   Wyświetlenie stanu Zarejestrowane trwa kilka minut.

2. Sprawdź stan rejestracji przy użyciu az feature show polecenia .

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

3. Kiedy status pokazuje Zarejestrowano, odśwież rejestrację dostawcy zasobów Microsoft.ContainerService, używając polecenia az provider register.

   az provider register --namespace "Microsoft.ContainerService"
   

Ustawianie zmiennych środowiskowych

Ustaw następujące zmienne środowiskowe, aby utworzyć unikatowe nazwy zasobów dla każdego wdrożenia. Zastąp <your-resource-group-name>, <your-region> i <your-cluster-name> własnymi wartościami. Opcjonalnie możesz użyć openssl rand -hex 3 polecenia , aby wygenerować losowy ciąg w celu dołączenia do grupy zasobów i nazw klastrów (na przykład export RESOURCE_GROUP="myResourceGroup$RANDOM_ID").

# Create random string
export RANDOM_ID="$(openssl rand -hex 3)"

# Set environment variables
export RESOURCE_GROUP="<your-resource-group-name>"
export REGION="<your-region>"
export CLUSTER_NAME="<your-cluster-name>"

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to logiczna grupa przeznaczona do wdrażania zasobów platformy Azure i zarządzania nimi. Podczas tworzenia grupy zasobów w Azure musisz określić lokalizację. Ta lokalizacja to lokalizacja magazynu metadanych grupy zasobów i lokalizacja, w której zasoby są uruchamiane w Azure, jeśli nie określisz innego regionu podczas tworzenia zasobu.

Utwórz grupę zasobów przy użyciu polecenia az group create.

az group create --name $RESOURCE_GROUP --location $REGION

Przykładowy wynik:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUPxxxxxx",
  "location": "$REGION",
  "managedBy": null,
  "name": "$RESOURCE_GROUPxxxxxx",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Tworzenie systemu Linux platformy Azure z klastrem OS Guard

Utwórz klaster AKS, używając polecenia az aks create z parametrem --os-sku, aby aprowizować klaster AKS przy użyciu obrazu Azure Linux z funkcją OS Guard.

az aks create --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --os-sku AzureLinuxOSGuard --node-osdisk-type Managed --enable-fips-image --enable-secure-boot --enable-vtpm 

Po kilku minutach polecenie zostanie wykonane i zwróci informacje o klastrze w formacie JSON.

Połącz się z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia Kubernetes, kubectl. kubectl jest już zainstalowany, jeśli używasz usługi Azure Cloud Shell. Aby zainstalować kubectl lokalnie, użyj az aks install-cli polecenia .

1. Skonfiguruj kubectl, aby nawiązać połączenie z klastrem Kubernetes za pomocą polecenia az aks get-credentials. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

   az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME
   

2. Zweryfikuj połączenie z klastrem, używając polecenia kubectl get. Ta komenda zwraca listę węzłów klastra.

   kubectl get nodes
   

Wdrażanie aplikacji

Aby wdrożyć aplikację, należy użyć pliku manifestu, aby utworzyć wszystkie obiekty wymagane do uruchomienia aplikacji AKS Store. Plik manifestu Kubernetes definiuje pożądany stan klastra, taki jak obrazy kontenerów do uruchomienia. Manifest obejmuje następujące wdrożenia i usługi Kubernetes:

• Front sklepu: aplikacja internetowa dla klientów do wyświetlania produktów i składania zamówień.
• Usługa produktu: wyświetla informacje o produkcie.
• Usługa zamówień: składa zamówienia.
• Rabbit MQ: system kolejkowania komunikatów dla kolejki zamówień.

1. Utwórz plik o nazwie aks-store-quickstart.yaml i skopiuj go w następującym manifeście:

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: rabbitmq
   spec:
     serviceName: rabbitmq
     replicas: 1
     selector:
       matchLabels:
         app: rabbitmq
     template:
       metadata:
         labels:
           app: rabbitmq
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: rabbitmq
           image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
           ports:
           - containerPort: 5672
             name: rabbitmq-amqp
           - containerPort: 15672
             name: rabbitmq-http
           env:
           - name: RABBITMQ_DEFAULT_USER
             value: "username"
           - name: RABBITMQ_DEFAULT_PASS
             value: "password"
           resources:
             requests:
               cpu: 10m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           volumeMounts:
           - name: rabbitmq-enabled-plugins
             mountPath: /etc/rabbitmq/enabled_plugins
             subPath: enabled_plugins
         volumes:
         - name: rabbitmq-enabled-plugins
           configMap:
             name: rabbitmq-enabled-plugins
             items:
             - key: rabbitmq_enabled_plugins
               path: enabled_plugins
   ---
   apiVersion: v1
   data:
     rabbitmq_enabled_plugins: |
       [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
   kind: ConfigMap
   metadata:
     name: rabbitmq-enabled-plugins            
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: rabbitmq
   spec:
     selector:
       app: rabbitmq
     ports:
       - name: rabbitmq-amqp
         port: 5672
         targetPort: 5672
       - name: rabbitmq-http
         port: 15672
         targetPort: 15672
     type: ClusterIP
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: order-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: order-service
     template:
       metadata:
         labels:
           app: order-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: order-service
           image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
           ports:
           - containerPort: 3000
           env:
           - name: ORDER_QUEUE_HOSTNAME
             value: "rabbitmq"
           - name: ORDER_QUEUE_PORT
             value: "5672"
           - name: ORDER_QUEUE_USERNAME
             value: "username"
           - name: ORDER_QUEUE_PASSWORD
             value: "password"
           - name: ORDER_QUEUE_NAME
             value: "orders"
           - name: FASTIFY_ADDRESS
             value: "0.0.0.0"
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
           startupProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 20
             periodSeconds: 10
           readinessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3000
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
         initContainers:
         - name: wait-for-rabbitmq
           image: busybox
           command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi    
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: order-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3000
       targetPort: 3000
     selector:
       app: order-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: product-service
     template:
       metadata:
         labels:
           app: product-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: product-service
           image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
           ports:
           - containerPort: 3002
           env: 
           - name: AI_SERVICE_URL
             value: "http://ai-service:5001/"
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 2m
               memory: 20Mi
           readinessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 5
           livenessProbe:
             httpGet:
               path: /health
               port: 3002
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: product-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3002
       targetPort: 3002
     selector:
       app: product-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: store-front
     template:
       metadata:
         labels:
           app: store-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: store-front
           image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
           ports:
           - containerPort: 8080
             name: store-front
           env: 
           - name: VUE_APP_ORDER_SERVICE_URL
             value: "http://order-service:3000/"
           - name: VUE_APP_PRODUCT_SERVICE_URL
             value: "http://product-service:3002/"
           resources:
             requests:
               cpu: 1m
               memory: 200Mi
             limits:
               cpu: 1000m
               memory: 512Mi
           startupProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 5
             periodSeconds: 5
           readinessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 3
             initialDelaySeconds: 3
             periodSeconds: 3
           livenessProbe:
             httpGet:
               path: /health
               port: 8080
             failureThreshold: 5
             initialDelaySeconds: 3
             periodSeconds: 3
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-front
   spec:
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: store-front
     type: LoadBalancer
   

   Jeśli tworzysz i zapisujesz plik YAML lokalnie, możesz przekazać plik manifestu do katalogu domyślnego w programie CloudShell, wybierając przycisk Przekaż/Pobierz pliki i wybierając plik z lokalnego systemu plików.

2. Wdróż aplikację przy użyciu kubectl apply polecenia i określ nazwę manifestu YAML.

   kubectl apply -f aks-store-quickstart.yaml
   

Testowanie aplikacji

Możesz sprawdzić, czy aplikacja jest uruchomiona, odwiedzając publiczny adres IP lub adres URL aplikacji.

Pobierz adres URL aplikacji przy użyciu następujących poleceń:

runtime="5 minutes"
endtime=$(date -ud "$runtime" +%s)
while [[ $(date -u +%s) -le $endtime ]]
do
   STATUS=$(kubectl get pods -l app=store-front -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}')
   echo $STATUS
   if [ "$STATUS" == 'True' ]
   then
      export IP_ADDRESS=$(kubectl get service store-front --output 'jsonpath={..status.loadBalancer.ingress[0].ip}')
      echo "Service IP Address: $IP_ADDRESS"
      break
   else
      sleep 10
   fi
done

curl $IP_ADDRESS

Wyniki:

<!doctype html>
<html lang="">
   <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <link rel="icon" href="/favicon.ico">
      <title>store-front</title>
      <script defer="defer" src="/js/chunk-vendors.df69ae47.js"></script>
      <script defer="defer" src="/js/app.7e8cfbb2.js"></script>
      <link href="/css/app.a5dc49f6.css" rel="stylesheet">
   </head>
   <body>
      <div id="app"></div>
   </body>
</html>

echo "You can now visit your web server at $IP_ADDRESS"

Usuwanie klastra

Jeśli nie potrzebujesz już tych zasobów, możesz wyczyścić niepotrzebne zasoby, aby uniknąć opłat za platformę Azure.

Usuń grupę zasobów Azure i wszystkie powiązane zasoby przy użyciu polecenia az group delete.

az group delete --name $RESOURCE_GROUP --yes --no-wait

Treści powiązane

W tej instrukcji szybkiego startu wdrożono klaster Azure Linux z mechanizmem OS Guard. Aby dowiedzieć się więcej na temat systemu Azure Linux z funkcją OS Guard, zobacz następujące zasoby:

• seria samouczków Azure Linux OS Guard: Część 1
• Przegląd funkcji Azure Linux OS Guard dla usługi AKS