Quickstart: Een Azure Linux-containerhost implementeren voor een AKS-cluster met behulp van Azure PowerShell

Artikel
09/27/2024

Ga aan de slag met de Azure Linux-containerhost met behulp van Azure PowerShell om een Azure Linux-containerhost voor een AKS-cluster te implementeren. Nadat u de vereisten hebt geïnstalleerd, maakt u een resourcegroep, maakt u een AKS-cluster, maakt u verbinding met het cluster en voert u een voorbeeldtoepassing met meerdere containers uit in het cluster.

Vereisten

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.
Gebruik de PowerShell-omgeving in Azure Cloud Shell. Zie de quickstart voor Azure Cloud Shell voor meer informatie.
Als u PowerShell lokaal uitvoert, installeert u de Az PowerShell module en maakt u verbinding met uw Azure-account met behulp van de Connect-AzAccount cmdlet. Zie Azure PowerShell installeren voor meer informatie over het installeren van de Az-module van PowerShell.
De identiteit die u gebruikt om uw cluster te maken, heeft de juiste minimale machtigingen. Zie Toegangs- en identiteitsopties voor Azure Kubernetes Service (AKS) voor meer informatie over toegang en identiteit voor AKS.

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd. Wanneer u een resourcegroep maakt, moet u een locatie opgeven. Deze locatie is de opslaglocatie van de metagegevens van uw resourcegroep en waar uw resources worden uitgevoerd in Azure als u geen andere regio opgeeft tijdens het maken van de resource.

In het volgende voorbeeld wordt een resourcegroep met de naam testAzureLinuxResourceGroup gemaakt in de regio Eastus .

Maak een resourcegroep met behulp van de New-AzResourceGroup cmdlet.

New-AzResourceGroup -Name testAzureLinuxResourceGroup -Location eastus

De volgende voorbeelduitvoer lijkt op een geslaagde creatie van de resourcegroep:

ResourceGroupName : testAzureLinuxResourceGroup
Location          : eastus
ProvisioningState : Succeeded
Tags              :
ResourceId        : /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/testAzureLinuxResourceGroup

Notitie

In het bovenstaande voorbeeld worden eastus gebruikt, maar Azure Linux Container Host-clusters zijn beschikbaar in alle regio's.

Een Azure Linux Container Host-cluster maken

In het volgende voorbeeld wordt een cluster gemaakt met de naam testAzureLinuxCluster met één knooppunt.

Maak een AKS-cluster met behulp van de New-AzAksCluster cmdlet met de -NodeOsSKU vlag ingesteld op AzureLinux.
```
New-AzAksCluster -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster -NodeOsSKU AzureLinux
```
Na enkele minuten is de opdracht voltooid en retourneert deze informatie over het cluster in JSON-indeling.

Verbinding maken met het cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt u de Kubernetes-opdrachtregelclient kubectl. kubectl is al geïnstalleerd als u Azure Cloud Shell gebruikt.

Lokaal installeren kubectl met behulp van de Install-AzAksCliTool cmdlet.
```
Install-AzAksCliTool
```
Configureer kubectl deze om verbinding te maken met uw Kubernetes-cluster met behulp van de Import-AzAksCredential cmdlet. Bij deze opdracht worden referenties gedownload en wordt Kubernetes CLI geconfigureerd voor het gebruik van deze referenties.
```
Import-AzAksCredential -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster
```
Controleer de verbinding met uw cluster met behulp van de kubectl get opdracht. Met deze opdracht wordt een lijst met de clusterpods geretourneerd.
```
kubectl get pods --all-namespaces
```

De toepassing implementeren

Als u de toepassing wilt implementeren, gebruikt u een manifestbestand om alle objecten te maken die nodig zijn om de AKS Store-toepassing uit te voeren. Een Kubernetes-manifestbestand definieert de gewenste status van een cluster, zoals welke containerinstallatiekopieën moeten worden uitgevoerd. Het manifest bevat de volgende Kubernetes-implementaties en -services:

Webwinkel: Webtoepassing voor klanten om producten te bekijken en bestellingen te plaatsen.
Productservice: toont productgegevens.
Orderservice: Orders plaatsen.
Rabbit MQ: Berichtenwachtrij voor een orderwachtrij.

Notitie

Het is niet raadzaam stateful containers, zoals Rabbit MQ, uit te voeren zonder permanente opslag voor productie. Deze worden hier gebruikt voor het gemak, maar we raden u aan beheerde services te gebruiken, zoals Azure Cosmos DB of Azure Service Bus.

Maak een bestand met de naam aks-store-quickstart.yaml en kopieer dit in het volgende manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rabbitmq
spec:
  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
      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
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 1m
            memory: 7Mi
---
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
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

Als u het YAML-bestand lokaal maakt en opslaat, kunt u het manifestbestand uploaden naar uw standaardmap in CloudShell door de knop Bestanden uploaden/downloaden te selecteren en het bestand in uw lokale bestandssysteem te selecteren.

Implementeer de toepassing met behulp van de opdracht kubectl apply en geef de naam van uw YAML-manifest op.

kubectl apply -f aks-store-quickstart.yaml

In de volgende voorbeelduitvoer ziet u de implementaties en services:

deployment.apps/rabbitmq created
service/rabbitmq created
deployment.apps/order-service created
service/order-service created
deployment.apps/product-service created
service/product-service created
deployment.apps/store-front created
service/store-front created

De toepassing testen

Wanneer de toepassing wordt uitgevoerd, maakt een Kubernetes-service de front-end van de toepassing beschikbaar op internet. Dit proces kan enkele minuten duren.

Controleer de status van de geïmplementeerde pods met behulp van de opdracht kubectl get pods . Zorg ervoor dat alle pods zijn Running voordat u doorgaat.
```
kubectl get pods
```
Controleer op een openbaar IP-adres voor de store-front-toepassing. Controleer de voortgang met behulp van de opdracht kubectl get service met het --watch argument.
```
kubectl get service store-front --watch
```
De UITVOER VAN HET EXTERNE IP-adres voor de store-front service wordt in eerste instantie weergegeven als in behandeling:
```
NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
```
Zodra het EXTERNAL-IP-adres is gewijzigd in een daadwerkelijk openbaar IP-adres, gebruikt CTRL-C u dit om het kubectl controleproces te stoppen.

In de volgende voorbeelduitvoer ziet u een geldig openbaar IP-adres dat aan de service is toegewezen:
```
NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
```
Open een webbrowser naar het externe IP-adres van uw service om de Azure Store-app in actie te zien.

Het cluster verwijderen

Als u niet van plan bent om door te gaan met de volgende zelfstudies, verwijdert u de gemaakte resources om te voorkomen dat Azure-kosten in rekening worden gebracht.

Verwijder de resourcegroep en alle gerelateerde resources met behulp van de RemoveAzResourceGroup cmdlet.
```
Remove-AzResourceGroup -Name testAzureLinuxResourceGroup
```

Volgende stappen

In deze quickstart hebt u een Azure Linux Container Host AKS-cluster geïmplementeerd. Als u meer wilt weten over de Azure Linux Container Host en een volledig voorbeeld van clusterimplementatie en -beheer doorloopt, gaat u verder met de zelfstudie over Azure Linux Container Host.

Zelfstudie over Azure Linux Container Host

Delen via