Anthos clusters on VMware ora è Google Distributed Cloud (solo software) per VMware. Per ulteriori informazioni, consulta la panoramica del prodotto.

Questa pagina è stata tradotta dall'API Cloud Translation.

Implementare 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 qui riportato, è necessario un cluster utente che utilizza bilanciamento del carico MetalLB in bundle. Per istruzioni sulla creazione di un cluster utente minimo che utilizza MetalLB, consulta Crea cluster di base.

Puoi utilizzare la console Google Cloud o lo strumento a riga di comando kubectl alla tua workstation di amministrazione per eseguire il deployment dell'applicazione.

Console

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

Vai ai cluster GKE
Nell'elenco dei cluster, fai clic sul cluster utente e verifica di hanno eseguito l'accesso al cluster.

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

Container

In Nuovo contenitore, seleziona Immagine container esistente.
Per Percorso immagine, inserisci us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.
Fai clic su Continua.

Configurazione

In Nome deployment, inserisci my-deployment.
In Spazio dei nomi, inserisci default.
Inserisci queste due etichette:
- Chiave 1: app, Valore 1: metrics
- Chiave 2: department, Valore 2 sales
Nel menu a discesa Cluster Kubernetes, seleziona il cluster.
Fai clic su Continua.

Mostra

Seleziona Esponi il deployment come nuovo servizio.
Per Porta 1, inserisci 80.
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 vedere questo osservando Dockerfile e il codice sorgente per l'app.
In Protocollo 1, seleziona TCP.
In Tipo di servizio, seleziona LoadBalancer.

Nella parte inferiore della pagina, fai clic sul pulsante Esegui il deployment.

Visualizzare i dettagli del deployment e del servizio

Quando il deployment è pronto, viene aperta la pagina Dettagli deployment nella sezione Carichi di lavoro Kubernetes della console Google Cloud. In questa pagina puoi trovare informazioni dettagliate del deployment e dei suoi tre pod.
In Servizi di esposizione, fai clic sul nome del servizio che espone il tuo deployment. Per questo esercizio, il nome è my-deployment-service.
Si apre la pagina Dettagli del servizio. In questa pagina puoi trovare informazioni dettagliate assistenza. 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 vedere un valore per IP bilanciatore del carico. L'IP del bilanciatore del carico configurata automaticamente sul bilanciatore del carico del cluster.

Inoltro per il Servizio

Supponiamo che un client esterno al cluster invii una richiesta all'indirizzo IP del bilanciatore del carico sulla porta TCP 80. La richiesta viene instradata al bilanciatore del carico del cluster. Il carico inoltra la richiesta a un pod del membro sulla porta TCP 8080. Ricorda ogni pod in my-deployment dispone di 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 di Google Cloud.

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

Riga di comando

Connettiti 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 file kubeconfig per il tuo 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 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 della specifica e dello 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 i dettagli ben formattati del deployment, incluso 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 clienti 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, di seguito sono riportati gli aspetti importanti da conoscere sul 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 questi etichette.
Quando un client invia una richiesta al servizio sulla porta TCP 80, la richiesta viene inoltrato a un pod del 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 rimane in ascolto sulla porta TCP 8080. Puoi verificarlo osservando 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'loadBalancerIP indirizzo sul bilanciatore del carico del cluster.

Visualizza il tuo servizio:

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

L'output è simile al seguente:

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. Ha anche un port e un targetPort.

clusterIP non è pertinente per questo esercizio. loadBalancerIP è l'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. Supponiamo che il tuo servizio ha 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 instradato al bilanciatore del carico del cluster. Il bilanciatore del carico inoltra la richiesta a un pod 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 tuo servizio

Eliminare 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 deployment sia stato eliminato:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployments

L'output non mostra più my-deployment.

Passaggi successivi

Creare un servizio e un Ingress