Implementare un'applicazione

Questo documento fornisce un esempio di come eseguire il deployment di un'applicazione in un cluster utente per GKE su VMware.

Prima di iniziare

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

Console

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

    Vai ai cluster GKE

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

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

  3. Nella parte superiore della pagina, fai clic su Esegui il deployment.

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.

Esponi

  1. Seleziona Esponi il deployment come nuovo servizio.

  2. Per la 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 di deployment e servizio

  1. Quando il deployment è pronto, si apre la pagina Dettagli deployment nella sezione carichi di lavoro Kubernetes della console Google Cloud. In questa pagina puoi vedere i dettagli del deployment e dei suoi 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 vedere i dettagli del servizio. Ad esempio, puoi vedere che qualsiasi pod con le etichette app: metrics e department: sales fa parte 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 al pod di un membro sulla porta TCP 8080. Ricorda che ogni pod in my-deployment dispone di un container in ascolto sulla porta TCP 8080.

Testare il servizio

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

Per chiamare il tuo 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. Questa operazione elimina sia il deployment sia il servizio di esposizione.

Riga di comando

Connettiti alla workstation di amministrazione

Ottieni una connessione SSH alla workstation di amministrazione. Segui questi 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 comando Deployment:

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

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

Recupera le informazioni di base sul tuo deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployment my-deployment

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

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

Elenca i pod nel tuo 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 relativi alla specifica e allo stato del deployment:

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 dettagli formattati correttamente sul deployment, tra cui il ReplicaSet associato:

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.

Di seguito è riportato il 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 questa esercizio, di seguito sono riportati gli aspetti importanti relativi al Servizio da conoscere:

  • Qualsiasi pod con l'etichetta app: metrics e l'etichetta department: sales fa parte 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 al pod di un membro sulla porta TCP 8080.

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

Succede che, per impostazione predefinita, il container hello-app rimane in ascolto sulla porta TCP 8080. Puoi verificarlo osservando 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, GKE su VMware configura automaticamente l'indirizzo loadBalancerIP sul bilanciatore del carico del cluster.

Visualizza il 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 servizio ha un clusterIP e un loadBalancerIP. Ha anche un port e un targetPort.

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

Ad esempio, prendi i valori mostrati nell'output precedente. Ovvero, 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 al pod di un membro sulla porta TCP 8080.

Chiama il 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

Elimina 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.

Elimina il tuo deployment

Elimina il tuo deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete deployment my-deployment

Verifica che il tuo 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