Esegui il deployment di un'applicazione

Questo documento fornisce un esempio di come eseguire il deployment di un'applicazione in un cluster utente creato con Google Distributed Cloud (solo software) per VMware.

Prima di iniziare

Per l'esempio riportato qui, è necessario un cluster utente che utilizzi il bilanciamento del carico MetalLB in bundle. Per istruzioni sulla creazione di un cluster utente minimo che utilizza MetalLB, consulta Crea cluster di base.

Per eseguire il deployment dell'applicazione, puoi utilizzare la Google Cloud console o lo strumento a riga di comando kubectl sulla workstation amministrativa.

Console

  1. Nella console, vai alla pagina Panoramica dei cluster Google Kubernetes Engine.

    Vai ai cluster GKE

  2. Nell'elenco dei cluster, fai clic sul tuo cluster utente e verifica di aver eseguito l'accesso al cluster.

    Se non hai ancora eseguito l'accesso al cluster utente, accedi seguendo le istruzioni riportate in Gestire i cluster dalla console. Google Cloud

Container

  1. In Nuovo contenitore, seleziona Immagine container esistente.

  2. In Percorso immagine, inserisci us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.

  3. Fai clic su Continua.

Configurazione

  1. In Nome deployment, inserisci my-deployment.

  2. In Spazio dei nomi, inserisci default.

  3. Inserisci queste due etichette:

    • Chiave 1: app, Valore 1: metrics
    • Chiave 2: department, Valore 2 sales

  4. Nel menu a discesa Cluster Kubernetes, seleziona il tuo cluster.

  5. Fai clic su Continua.

Expose

  1. Seleziona Esponi il deployment come nuovo servizio.

  2. In Porta 1, inserisci 80.

  3. In Porta di destinazione 1, inserisci 8080. Questo è il valore appropriato perché il container hello-app rimane in ascolto sulla porta TCP 8080 per impostazione predefinita. Puoi verificarlo esaminando il Dockerfile e il codice sorgente dell'app.

  4. In Protocollo 1, seleziona TCP.

  5. In Tipo di servizio, seleziona LoadBalancer.

In fondo alla pagina, fai clic sul pulsante Esegui il deployment.

Visualizzare i dettagli del deployment e del servizio

  1. Quando il deployment è pronto, la pagina Dettagli deployment si apre nella sezione Workload Kubernetes della console Google Cloud . In questa pagina puoi visualizzare i dettagli del deployment e dei relativi tre pod.

  2. In Servizi di esposizione, fai clic sul nome del servizio che espone il tuo deployment. Per questo esercizio, il nome è my-deployment-service.

  3. Viene visualizzata la pagina Dettagli servizio. In questa pagina puoi visualizzare i dettagli del servizio. Ad esempio, puoi vedere che qualsiasi pod con le etichette app: metrics e department: sales è membro del servizio. Ricorda che i pod in my-deployment hanno queste etichette.

Puoi anche visualizzare un valore per IP bilanciatore del carico. L'IP del bilanciatore del carico è stato configurato automaticamente sul bilanciatore del carico del cluster.

Inoltro per il Servizio

Supponiamo che un client esterno al cluster invii una richiesta all'IP del bilanciatore del carico sulla porta TCP 80. La richiesta viene instradata al bilanciatore del carico del cluster. Il bilanciatore del carico inoltra la richiesta a un pod membro sulla porta TCP 8080. Ricorda che ogni pod in my-deployment ha un container in ascolto sulla porta TCP 8080.

Testare il Servizio

Vai a una macchina in cui l'IP del bilanciatore del carico è instradabile.

Per chiamare il servizio, inserisci l'IP del bilanciatore del carico in un browser o utilizza un comando come curl. Ad esempio:

curl [LOAD_BALANCER_IP]:80

L'output mostra un messaggio Hello, world!. Ad esempio:

curl 203.0.113.1:80
Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-9wpbv

Eliminare il deployment

Vai alla pagina Carichi di lavoro nella sezione Kubernetes Engine della console.

Vai alla pagina Carichi di lavoro

Nell'elenco dei deployment, seleziona my-deployment.

Nella parte superiore della pagina, fai clic su Elimina. Vengono eliminati sia il deployment sia il servizio di esposizione.

Riga di comando

Connettersi alla workstation di amministrazione

Ottieni una connessione SSH alla tua workstation di amministrazione. Esegui i seguenti passaggi sulla workstation di amministrazione.

Creazione di un deployment

Ecco un manifest per un deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      app: metrics
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: sales
    spec:
      containers:
      - name: hello
        image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"

Copia il manifest in un file denominato my-deployment.yaml e crea il Deployment:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-deployment.yaml

dove USER_CLUSTER_KUBECONFIG è il percorso del file kubeconfig per il cluster utente.

Ottieni informazioni di base sul tuo deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployment my-deployment

L'output mostra che il deployment ha tre pod tutti disponibili:

NAME            READY   UP-TO-DATE   AVAILABLE   AGE
my-deployment   3/3     3            3           27s

Elenca i pod nel deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get pods

L'output mostra che il deployment ha tre pod in esecuzione:

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-54944c8d55-4srm2   1/1     Running   0          6s
my-deployment-54944c8d55-7z5nn   1/1     Running   0          6s
my-deployment-54944c8d55-j62n9   1/1     Running   0          6s

Ottieni informazioni dettagliate sul tuo deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployment my-deployment --output yaml

L'output mostra i dettagli della specifica di deployment e dello stato:

kind: Deployment
metadata:
  ...
  generation: 1
  name: my-deployment
  namespace: default
  ...
spec:
  ...
  replicas: 3
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: metrics
      department: sales
  ...
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: hello
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
status:
  availableReplicas: 3
  conditions:
  ‑ lastTransitionTime: "2019-11-11T18:44:02Z"
    lastUpdateTime: "2019-11-11T18:44:02Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  ‑ lastTransitionTime: "2019-11-11T18:43:58Z"
    lastUpdateTime: "2019-11-11T18:44:02Z"
    message: ReplicaSet "my-deployment-54944c8d55" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Descrivi il tuo deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG describe deployment my-deployment

L'output mostra i dettagli della deployment in un formato ben strutturato, inclusi i ReplicaSet associati:

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Mon, 11 Nov 2019 10:43:58 -0800
Labels:                 
...
Selector:               app=metrics,department=sales
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=metrics
           department=sales
  Containers:
    hello:
    Image:        us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
    Port:         
    Host Port:    
    Environment:  
    Mounts:       
  Volumes:        
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  
NewReplicaSet:   my-deployment-54944c8d55 (3/3 replicas created)

Crea un servizio di tipo LoadBalancer

Un modo per esporre il deployment ai client esterni al cluster è creare un servizio Kubernetes di tipo LoadBalancer.

Ecco un manifest per un servizio di tipo LoadBalancer:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  ports:
  ‑ port: 80
    targetPort: 8080

Ai fini di questo esercizio, ecco gli aspetti importanti da comprendere del Servizio:

  • Qualsiasi pod con l'etichetta app: metrics e l'etichetta department: sales è membro del servizio. Tieni presente che i pod in my-deployment hanno queste etichette.

  • Quando un client invia una richiesta al servizio sulla porta TCP 80, la richiesta viene inoltrata a un pod membro sulla porta TCP 8080.

  • Ogni pod membro deve avere un container in ascolto sulla porta TCP 8080.

Per impostazione predefinita, il container hello-app è in ascolto sulla porta TCP 8080. Puoi verificarlo esaminando il Dockerfile e il codice sorgente dell'app.

Salva il manifest in un file denominato my-service.yaml e crea il servizio:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG apply -f my-service.yaml

dove USER_CLUSTER_KUBECONFIG è il percorso del file kubeconfig per il cluster utente.

Quando crei il servizio, Google Distributed Cloud configura automaticamente l'indirizzo loadBalancerIP sul bilanciatore del carico del cluster.

Visualizza il tuo servizio:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get service my-service --output yaml

L'output è simile a questo:

kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.1.39
  clusterIPs:
  - 10.96.1.39
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31184
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

Nell'output precedente, puoi vedere che il tuo servizio ha un clusterIP e un loadBalancerIP. Dispone inoltre di un port e di un targetPort.

clusterIP non è pertinente a questo esercizio. loadBalancerIP è l'indirizzo IP che i client al di fuori del cluster possono utilizzare per chiamare il servizio.

Ad esempio, prendi i valori mostrati nell'output precedente. Supponiamo che il tuo servizio abbia loadBalancerIP = 203.0.113.1, port = 80 e targetPort = 8080.

Un client invia una richiesta a 203.0.113.1 sulla porta TCP 80. La richiesta viene instradata al bilanciatore del carico del cluster. Il bilanciatore del carico inoltra la richiesta a un pod membro sulla porta TCP 8080.

Chiama il tuo servizio:

curl LOAD_BALANCER_IP

L'output mostra un messaggio Hello, world!:

curl 203.0.113.1
Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-9wpbv

Eliminare il servizio

Elimina il servizio:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete service my-service

Verifica che il servizio sia stato eliminato:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get services

L'output non mostra più my-service.

Eliminare il deployment

Elimina il deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete deployment my-deployment

Verifica che il deployment sia stato eliminato:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployments

L'output non mostra più my-deployment.

Passaggi successivi

Crea un servizio e un Ingress