Condividi tramite


Usare kubectl per eseguire un'applicazione con stato Kubernetes con Archiviazione Class nel dispositivo AZURE Stack Edge Pro GPU

SI APPLICA A:Yes for Pro GPU SKUAzure Stack Edge Pro - GPUYes for Pro 2 SKUAzure Stack Edge Pro 2Yes for Pro R SKUAzure Stack Edge Pro RYes for Mini R SKUAzure Stack Edge Mini R

Questo articolo illustra come distribuire un'applicazione con stato a istanza singola in Kubernetes usando una Archiviazione Class per effettuare il provisioning dinamico dell'archiviazione e di una distribuzione. La distribuzione usa kubectl i comandi in un cluster Kubernetes esistente e distribuisce l'applicazione MySQL.

Questa procedura è destinata a coloro che hanno esaminato l'archiviazione Kubernetes nel dispositivo Azure Stack Edge Pro e hanno familiarità con i concetti dell'archiviazione Kubernetes.

Prerequisiti

Prima di poter distribuire l'applicazione con stato, completare i prerequisiti seguenti nel dispositivo e nel client che si userà per accedere al dispositivo:

Per il dispositivo

  • Si dispone di credenziali di accesso a un dispositivo Azure Stack Edge Pro a 1 nodo.
    • Il dispositivo viene attivato. Vedi Attivare il dispositivo.
    • Il dispositivo ha il ruolo di calcolo configurato tramite portale di Azure e ha un cluster Kubernetes. Vedere Configurare il calcolo.

Per l'accesso del client al dispositivo

  • Si dispone di un sistema client Windows che verrà usato per accedere al dispositivo Azure Stack Edge Pro.
    • Il client esegue Windows PowerShell 5.0 o versione successiva. Per scaricare la versione più recente di Windows PowerShell, passare a Installa Windows PowerShell.

    • È possibile avere anche qualsiasi altro client con un sistema operativo supportato. Questo articolo descrive la procedura quando si usa un client Windows.

    • La procedura descritta in Accedere al cluster Kubernetes nel dispositivo Azure Stack Edge Pro è stata completata. Precisamente:

      • È stato creato uno userns1 spazio dei nomi tramite il New-HcsKubernetesNamespace comando .
      • Creazione di un utente user1 tramite il New-HcsKubernetesUser comando .
      • Concesso l'accesso user1 a userns1 tramite il Grant-HcsKubernetesNamespaceAccess comando .
      • Installato kubectl nel client e salvato il kubeconfig file con la configurazione utente in C:\Users\<username>\.kube.
    • Assicurarsi che la kubectl versione del client non sia asimmetrica da una versione della versione master kubernetes in esecuzione nel dispositivo Azure Stack Edge Pro.

      • Usare kubectl version per controllare la versione di kubectl in esecuzione nel client. Prendere nota della versione completa.
      • Nell'interfaccia utente locale del dispositivo Azure Stack Edge Pro passare a Panoramica e prendere nota del numero di software Kubernetes.
      • Verificare che queste due versioni siano compatibili con il mapping fornito nella versione di Kubernetes supportata.

È possibile distribuire un'applicazione con stato nel dispositivo Azure Stack Edge Pro.

Distribuire MySQL

A questo punto si eseguirà un'applicazione con stato creando una distribuzione Kubernetes e collegandola alla Archiviazione Class predefinita usando un PersistentVolumeClaim (PVC).

Tutti i kubectl comandi usati per creare e gestire distribuzioni di applicazioni con stato devono specificare lo spazio dei nomi associato alla configurazione. Per specificare lo spazio dei nomi in un comando kubectl, usare kubectl <command> -n <your-namespace>.

  1. Ottenere un elenco dei pod in esecuzione nel cluster Kubernetes nello spazio dei nomi. Un pod è un contenitore di applicazioni o un processo in esecuzione nel cluster Kubernetes.

    kubectl get pods -n <your-namespace>
    

    Di seguito è riportato un esempio di sintassi del comando:

     C:\Users\user>kubectl get pods -n "userns1"
     No resources found in userns1 namespace.    
     C:\Users\user>
    

    L'output deve indicare che non vengono trovate risorse (pod) perché non sono in esecuzione applicazioni nel cluster.

  2. Verranno usati i file YAML seguenti. Il mysql-deployment.yml file descrive una distribuzione che esegue MySQL e fa riferimento al PVC. Il file definisce un montaggio del volume per /var/lib/mysqle quindi crea un PVC che cerca un volume di 20 GB. Viene effettuato il provisioning di un PV dinamico e il PVC è associato a questo PV.

    Copiare e salvare il file seguente mysql-deployment.yml in una cartella nel client Windows in uso per accedere al dispositivo Azure Stack Edge Pro.

    apiVersion: v1
    kind: Service
    metadata:
      name: mysql
    spec:
      ports:
      - port: 3306
      selector:
        app: mysql
      clusterIP: None
    ---
    apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
    kind: Deployment
    metadata:
      name: mysql
    spec:
      selector:
        matchLabels:
          app: mysql
      strategy:
        type: Recreate
      template:
        metadata:
          labels:
            app: mysql
        spec:
          containers:
          - image: mysql:5.6
            name: mysql
            env:
              # Use secret in real usage
            - name: MYSQL_ROOT_PASSWORD
              value: password
            ports:
            - containerPort: 3306
              name: mysql
            volumeMounts:
            - name: mysql-persistent-storage
              mountPath: /var/lib/mysql
          volumes:
          - name: mysql-persistent-storage
            persistentVolumeClaim:
              claimName: mysql-pv-claim-sc
    
  3. Copiare e salvare come mysql-pvc.yml file nella stessa cartella in cui è stato salvato .mysql-deployment.yml Per usare la Archiviazione Class predefinita su cui il dispositivo Azure Stack Edge Pro in un disco dati collegato, impostare il storageClassName campo nell'oggetto PVC su ase-node-local e accessModes deve essere ReadWriteOnce.

    Nota

    Assicurarsi che i file YAML abbiano un rientro corretto. È possibile controllare con YAML lint per convalidare e quindi salvare.

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: mysql-pv-claim-sc
    spec:
      storageClassName: ase-node-local
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 20Gi
    
  4. Distribuire il mysql-pvc.yaml file.

    kubectl apply -f <URI path to the mysql-pv.yml file> -n <your-user-namespace>

    Ecco un output di esempio della distribuzione.

    C:\Users\user>kubectl apply -f "C:\stateful-application\mysql-pvc.yml" -n userns1
    persistentvolumeclaim/mysql-pv-claim-sc created
    C:\Users\user>
    

    Si noti il nome del PVC creato, in questo esempio . mysql-pv-claim-sc Verrà usato in un passaggio successivo.

  5. Distribuire il contenuto del mysql-deployment.yml file.

    kubectl apply -f <URI path to mysql-deployment.yml file> -n <your-user-namespace>

    Ecco un output di esempio della distribuzione.

    C:\Users\user>kubectl apply -f "C:\stateful-application\mysql-deployment.yml" -n userns1
    service/mysql created
    deployment.apps/mysql created
    C:\Users\user>
    
  6. Visualizzare informazioni sulla distribuzione.

    kubectl describe deployment <app-label> -n <your-user-namespace>

    C:\Users\user>kubectl describe deployment mysql -n userns1
    Name:               mysql
    Namespace:          userns1
    CreationTimestamp:  Thu, 20 Aug 2020 11:14:25 -0700
    Labels:             <none>
    Annotations:        deployment.kubernetes.io/revision: 1
                        kubectl.kubernetes.io/last-applied-configuration:
                          {"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{},"name":"mysql","namespace":"userns1"},"spec":{"selector":{"matchL...
    Selector:           app=mysql
    Replicas:           1 desired | 1 updated | 1 total | 1 available | 0 unavailable
    StrategyType:       Recreate
    MinReadySeconds:    0
    Pod Template:
      Labels:  app=mysql
      Containers:
       mysql:
        Image:      mysql:5.6
        Port:       3306/TCP
        Host Port:  0/TCP
        Environment:
          MYSQL_ROOT_PASSWORD:  password
        Mounts:
          /var/lib/mysql from mysql-persistent-storage (rw)
      Volumes:
       mysql-persistent-storage:
        Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
        ClaimName:  mysql-pv-claim-sc
        ReadOnly:   false
    Conditions:
      Type           Status  Reason
      ----           ------  ------
      Available      True    MinimumReplicasAvailable
      Progressing    True    NewReplicaSetAvailable
    OldReplicaSets:  <none>
    NewReplicaSet:   mysql-695c4d9dcd (1/1 replicas created)
    Events:
      Type    Reason             Age   From                   Message
      ----    ------             ----  ----                   -------
      Normal  ScalingReplicaSet  24s   deployment-controller  Scaled up replica set mysql-695c4d9dcd to 1
    C:\Users\user>
    
  7. Elencare i pod creati dalla distribuzione.

    kubectl get pods -l <app=label> -n <your-user-namespace>

    Ecco un output di esempio.

    C:\Users\user>kubectl get pods -l app=mysql -n userns1
    NAME                     READY   STATUS    RESTARTS   AGE
    mysql-695c4d9dcd-rvzff   1/1     Running   0          40s
    C:\Users\user>
    
  8. Esaminare PersistentVolumeClaim.

    kubectl describe pvc <your-pvc-name>

    Ecco un output di esempio.

    C:\Users\user>kubectl describe pvc mysql-pv-claim-sc -n userns1
    Name:          mysql-pv-claim-sc
    Namespace:     userns1
    StorageClass:  ase-node-local
    Status:        Bound
    Volume:        pvc-dc48253c-82dc-42a4-a7c6-aaddc97c9b8a
    Labels:        <none>
    Annotations:   kubectl.kubernetes.io/last-applied-configuration:
                     {"apiVersion":"v1","kind":"PersistentVolumeClaim","metadata":{"annotations":{},"name":"mysql-pv-claim-sc","namespace":"userns1"},"spec":{"...
                   pv.kubernetes.io/bind-completed: yes
                   pv.kubernetes.io/bound-by-controller: yes
                   volume.beta.kubernetes.io/storage-provisioner: rancher.io/local-path
                   volume.kubernetes.io/selected-node: k8s-3q7lhq2cl-3q7lhq2
    Finalizers:    [kubernetes.io/pvc-protection]
    Capacity:      20Gi
    Access Modes:  RWO
    VolumeMode:    Filesystem
    Mounted By:    mysql-695c4d9dcd-rvzff
    Events:
      Type    Reason                 Age                From                                                                                                Message
      ----    ------                 ----               ----                                                                                                -------
      Normal  WaitForFirstConsumer   71s (x2 over 77s)  persistentvolume-controller                                                                         waiting for first consumer to be created before binding
      Normal  ExternalProvisioning   62s                persistentvolume-controller                                                                         waiting for a volume to be created, either by external provisioner "rancher.io/local-path" or manually created by system administrator
      Normal  Provisioning           62s                rancher.io/local-path_local-path-provisioner-6b84988bf9-tx8mz_1896d824-f862-4cbf-912a-c8cc0ca05574  External provisioner is provisioning volume for claim "userns1/mysql-pv-claim-sc"
      Normal  ProvisioningSucceeded  60s                rancher.io/local-path_local-path-provisioner-6b84988bf9-tx8mz_1896d824-f862-4cbf-912a-c8cc0ca05574  Successfully provisioned volume pvc-dc48253c-82dc-42a4-a7c6-aaddc97c9b8a
    C:\Users\user>
    

Verificare che MySQL sia in esecuzione

Per verificare che l'applicazione sia in esecuzione, digitare:

kubectl exec <your-pod-with-the-app> -i -t -n <your-namespace> -- mysql -p

Quando richiesto, specificare la password. La password si trova nel mysql-deployment file.

Ecco un output di esempio.

C:\Users\user>kubectl exec mysql-695c4d9dcd-rvzff -i -t -n userns1 -- mysql -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.6.49 MySQL Community Server (GPL)

Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql>

Eliminare una distribuzione

Per eliminare la distribuzione, eliminare gli oggetti distribuiti in base al nome. Questi oggetti includono distribuzione, servizio e PVC.

kubectl delete deployment <deployment-name>,svc <service-name> -n <your-namespace>
kubectl delete pvc <your-pvc-name> -n <your-namespace>

Ecco l'output di esempio di quando si elimina la distribuzione e il servizio.

C:\Users\user>kubectl delete deployment,svc mysql -n userns1
deployment.apps "mysql" deleted
service "mysql" deleted
C:\Users\user>

Ecco l'output di esempio di quando si elimina il PVC.

C:\Users\user>kubectl delete pvc mysql-pv-claim-sc -n userns1
persistentvolumeclaim "mysql-pv-claim-sc" deleted
C:\Users\user>

Passaggi successivi

Per informazioni su come configurare la rete tramite kubectl, vedere Distribuire un'applicazione senza stato in un dispositivo Azure Stack Edge Pro