Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

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 il software Google Distributed Cloud solo per VMware.

Prima di iniziare

Per l'esempio riportato qui, è necessario un cluster utente che utilizzi il bilanciamento del carico MetalLB integrato. 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 console Google Cloud o lo strumento a riga di comando kubectl sulla tua workstation di amministrazione.

Console

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

Vai ai cluster GKE
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 Gestisci i cluster dalla console Google Cloud .

Container

In Nuovo container, seleziona Immagine container esistente.
In 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 tuo cluster.
Fai clic su Continua.

Expose

Seleziona Esponi il deployment come nuovo servizio.
In 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 vederlo esaminando il Dockerfile e il codice sorgente dell'app.
In Protocollo 1, seleziona TCP.
In Tipo di servizio, seleziona LoadBalancer.

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

Visualizza i dettagli di deployment e servizio

Quando il deployment è pronto, viene visualizzata la pagina Dettagli deployment nella sezione Workload Kubernetes della console Google Cloud . In questa pagina puoi visualizzare i dettagli 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.
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 è un membro del servizio. Ricorda che i pod in my-deployment hanno queste etichette.

Puoi anche visualizzare un valore per IP del 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.

Testa 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

Elimina il deployment

Vai alla pagina Workload nella sezione Kubernetes Engine della console.

Vai alla pagina Workload

Nell'elenco dei deployment, seleziona my-deployment.

Nella parte superiore della pagina, fai clic su Elimina. In questo modo vengono eliminati sia il deployment sia il servizio esposto.

Riga di comando

Connettiti alla workstation di amministrazione

Stabilisci una connessione SSH alla tua workstation di amministrazione. Esegui questi passaggi sulla tua 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 tuo 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, 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 deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG describe deployment my-deployment

L'output mostra i dettagli del deployment formattati correttamente, 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 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 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 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 rimane in ascolto sulla porta TCP 8080. Puoi vederlo 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 tuo 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 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'indirizzo IP che i client esterni al cluster possono utilizzare per chiamare il servizio.

Ad esempio, prendi i valori mostrati nell'output precedente. Ad esempio, 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 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 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

Esegui il deployment di un'applicazione Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.