Guia de início rápido: como implantar um aplicativo em uma linguagem específica

Nesta página, você aprende a fazer o seguinte:

1. Criar um aplicativo "Hello World".
2. Empacotar o aplicativo em uma imagem de contêiner usando o Cloud Build.
3. Criar um cluster no Google Kubernetes Engine (GKE).
4. Implantar a imagem de contêiner no cluster.

A amostra é exibida em várias linguagens, mas é possível usar outras além destas.

Antes de começar

1. Faça login na sua conta do Google.

   Se você ainda não tiver uma, inscreva-se.

2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar a página do seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

4. Ative as APIs Cloud Build and Google Kubernetes Engine.

   Ative as APIs

5. Instale e inicialize o SDK do Cloud..
6. kubectl é usado para gerenciar o Kubernetes, o sistema de orquestração de cluster usado pelo GKE. Instale kubectl usando gcloud:

   gcloud components install kubectl

Como escrever o aplicativo de amostra

Para instruções sobre como criar um aplicativo "Hello World" que seja executado no GKE, clique na linguagem usada por você:

Go

1. Crie um novo diretório com o nome helloworld-gke e altere o diretório nele:

   mkdir helloworld-gke
   cd helloworld-gke
   

2. Crie um novo módulo chamado example.com/helloworld:

   go mod init example.com/helloworld
   

3. Crie um novo arquivo chamado helloworld.go e cole o código a seguir nele:

   quickstart/go/helloworld.go

   Ver no GitHub (em inglês)

   package main
   
   import (
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   )
   
   func main() {
   	http.HandleFunc("/", handler)
   
   	port := os.Getenv("PORT")
   	if port == "" {
   		port = "8080"
   	}
   
   	log.Printf("Listening on localhost:%s", port)
   	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
   }
   
   func handler(w http.ResponseWriter, r *http.Request) {
   	log.Print("Hello world received a request.")
   	target := os.Getenv("TARGET")
   	if target == "" {
   		target = "World"
   	}
   	fmt.Fprintf(w, "Hello %s!\n", target)
   }
   

   Com esse código, você cria um servidor da Web que realiza detecções na porta definida pela variável de ambiente PORT.

Você concluiu seu aplicativo. Ele está pronto para ser empacotado em um contêiner do Docker e enviado por upload ao Container Registry.

Node.js

1. Crie um novo diretório com o nome helloworld-gke e altere o diretório nele:

   mkdir helloworld-gke
   cd helloworld-gke
   

2. Crie um arquivo package.json com o seguinte conteúdo:

   quickstart/nodejs/package.json

   Ver no GitHub (em inglês)

   {
     "name": "gke-helloworld",
     "version": "1.0.0",
     "description": "GKE hello world sample in Node",
     "main": "index.js",
     "scripts": {
       "start": "node index.js"
     },
     "author": "",
     "license": "Apache-2.0",
     "dependencies": {
       "express": "^4.16.4"
     }
   }
   

3. No mesmo diretório, crie um arquivo index.js e copie as seguintes linhas nele:

   quickstart/nodejs/index.js

   Ver no GitHub (em inglês)

   const express = require('express');
   const app = express();
   
   app.get('/', (req, res) => {
     console.log('Hello world received a request.');
   
     const target = process.env.TARGET || 'World';
     res.send(`Hello ${target}!`);
   });
   
   const port = process.env.PORT || 8080;
   app.listen(port, () => {
     console.log('Hello world listening on port', port);
   });
   

   Com esse código, você cria um servidor da Web que realiza detecções na porta definida pela variável de ambiente PORT.

Você concluiu seu aplicativo. Ele está pronto para ser empacotado em um contêiner do Docker e enviado por upload ao Container Registry.

Python

1. Crie um novo diretório com o nome helloworld-gke e altere o diretório nele:

   mkdir helloworld-gke
   cd helloworld-gke
   

2. Crie um arquivo chamado app.py e cole o seguinte código nele:

   quickstart/python/app.py

   Ver no GitHub (em inglês)

   import os
   
   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello_world():
       target = os.environ.get('TARGET', 'World')
       return 'Hello {}!\n'.format(target)
   
   if __name__ == "__main__":
       app.run(debug=True,host='0.0.0.0',port=int(os.environ.get('PORT', 8080)))
   

Java

Crie um aplicativo Spring Boot.

1. Instale JDK Java SE 8 ou superior e cURL (links em inglês). O Java SE e cURL são necessários apenas para criar o novo projeto da Web na próxima etapa. O Dockerfile, descrito posteriormente, carrega todas as dependências no contêiner.

2. No terminal, crie um novo projeto da Web vazio:

   curl https://start.spring.io/starter.zip \
       -d dependencies=web \
       -d javaVersion=1.8 \
       -d bootVersion=2.1.3.RELEASE \
       -d name=helloworld \
       -d artifactId=helloworld \
       -d baseDir=helloworld-gke \
       -o helloworld-gke.zip
   unzip helloworld-gke.zip
   cd helloworld-gke
   

   Agora você tem um novo projeto de inicialização do Spring em helloworld-gke.

3. No arquivo src/main/java/com/example/helloworld/HelloworldApplication.java, atualize a classe HelloworldApplication adicionando um @RestController para manipular o mapeamento /.

   quickstart/java/src/main/java/com/example/helloworld/HelloworldApplication.java

   Ver no GitHub (em inglês)

   package com.example.helloworld;
   
   import org.springframework.beans.factory.annotation.Value;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @SpringBootApplication
   public class HelloworldApplication {
   
   	@Value("${TARGET:World}")
   	String target;
   
   	@RestController
   	class HelloworldController {
   		@GetMapping("/")
   		String hello() {
   			return "Hello " + target + "!";
   		}
   	}
   
   	public static void main(String[] args) {
   		SpringApplication.run(HelloworldApplication.class, args);
   	}
   }
   

   Com esse código, você cria um servidor da Web que realiza detecções na porta definida pela variável de ambiente PORT.

Você concluiu seu aplicativo. Ele está pronto para ser empacotado em um contêiner do Docker e enviado por upload ao Container Registry.

C#

1. Instale o SDK do .NET Core 2.2 (em inglês). Ele é necessário apenas para criar o novo projeto da Web na próxima etapa. O Dockerfile, que é descrito posteriormente, carrega todas as dependências no contêiner.

2. No terminal, crie um novo projeto da Web vazio:

   dotnet new web -o helloworld-gke
   

3. Altere o diretório para helloworld-gke.

4. Atualize a definição CreateWebHostBuilder em Program.cs especificando o URL da porta para .UseUrls() para definir a porta de exibição. A amostra mostra a porta 8080, mas é possível usar outras. Seu servidor precisa detectar na porta que você especificar aqui:

   quickstart/dotnet/Program.cs

   Ver no GitHub (em inglês)

   // Copyright (c) 2019 Google LLC.
   //
   // Licensed under the Apache License, Version 2.0 (the "License"); you may not
   // use this file except in compliance with the License. You may obtain a copy of
   // the License at
   //
   // http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   // License for the specific language governing permissions and limitations under
   // the License.
   
   using System;
   using Microsoft.AspNetCore;
   using Microsoft.AspNetCore.Hosting;
   
   namespace HelloGKE
   {
       public class Program
       {
           public static void Main(string[] args)
           {
               CreateWebHostBuilder(args).Build().Run();
           }
   
           public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
               WebHost.CreateDefaultBuilder(args)
                   .UseStartup<Startup>()
                   .UsePortEnvironmentVariable();
       }
   
       static class ProgramExtensions
       {
           // Google Cloud Run sets the PORT environment variable to tell this
           // process which port to listen to.
           public static IWebHostBuilder UsePortEnvironmentVariable(
               this IWebHostBuilder builder)
           {
               string port = Environment.GetEnvironmentVariable("PORT");
               if (!string.IsNullOrEmpty(port))
               {
                   builder.UseUrls($"http://0.0.0.0:{port}");
               }
               return builder;
           }
       }
   }
   

Você concluiu seu aplicativo. Ele está pronto para ser empacotado em um contêiner do Docker e enviado por upload ao Container Registry.

PHP

1. Crie um novo diretório com o nome helloworld-gke e altere o diretório nele:

   mkdir helloworld-gke
   cd helloworld-gke
   

2. Crie um arquivo chamado index.php e cole o seguinte código nele:

   quickstart/php/index.php

   Ver no GitHub (em inglês)

   <?php
   $target = getenv('TARGET', true) ?: 'World';
   echo sprintf("Hello %s!", $target);
   

Você concluiu seu aplicativo. Ele está pronto para ser empacotado em um contêiner do Docker e enviado por upload ao Container Registry.

Ruby

1. Crie um novo diretório com o nome helloworld-gke e altere o diretório nele:

   mkdir helloworld-gke
   cd helloworld-gke
   

2. Crie um arquivo chamado app.rb e cole o seguinte código nele:

   quickstart/ruby/app.rb

   Ver no GitHub (em inglês)

   require 'sinatra'
   
   set :bind, '0.0.0.0'
   set :port, ENV['PORT'] || '8080'
   
   get '/' do
     target = ENV['TARGET'] || 'World'
     "Hello #{target}!\n"
   end
   

   Com esse código, você cria um servidor da Web que realiza detecções na porta definida pela variável de ambiente PORT.

3. Crie um arquivo chamado Gemfile e copie o seguinte arquivo nele:

   quickstart/ruby/Gemfile

   Ver no GitHub (em inglês)

   source 'https://rubygems.org'
   
   gem 'sinatra'
   gem 'rack', '>= 2.0.6'
   

Como contentorizar um aplicativo com o Cloud Build

1. Para contentorizar o aplicativo de amostra, crie um novo arquivo chamado Dockerfile no mesmo diretório dos arquivos de origem e copie o seguinte conteúdo:

   Go

   quickstart/go/Dockerfile

   Ver no GitHub (em inglês)

   # Use the offical Golang image to create a build artifact.
   # This is based on Debian and sets the GOPATH to /go.
   # https://hub.docker.com/_/golang
   FROM golang:1.12 as builder
   
   # Copy local code to the container image.
   WORKDIR /app
   COPY . .
   
   # Build the command inside the container.
   RUN CGO_ENABLED=0 GOOS=linux go build -v -o helloworld
   
   # Use a Docker multi-stage build to create a lean production image.
   # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
   FROM alpine
   RUN apk add --no-cache ca-certificates
   
   # Copy the binary to the production image from the builder stage.
   COPY --from=builder /app/helloworld /helloworld
   
   # Run the web service on container startup.
   CMD ["/helloworld"]
   

   Node.js

   quickstart/nodejs/Dockerfile

   Ver no GitHub (em inglês)

   # Use the official lightweight Node.js 10 image.
   # https://hub.docker.com/_/node
   FROM node:10-slim
   
   # Create and change to the app directory.
   WORKDIR /usr/src/app
   
   # Copy application dependency manifests to the container image.
   # A wildcard is used to ensure both package.json AND package-lock.json are copied.
   # Copying this separately prevents re-running npm install on every code change.
   COPY package*.json ./
   
   # Install production dependencies.
   RUN npm install --only=production
   
   # Copy local code to the container image.
   COPY . ./
   
   # Run the web service on container startup.
   CMD [ "npm", "start" ]
   

   Adicione outro arquivo .dockerignore para garantir que os arquivos locais não afetem o processo de criação do contêiner:

   quickstart/nodejs/.dockerignore

   Ver no GitHub (em inglês)

   Dockerfile
   README.md
   node_modules
   npm-debug.log
   

   Python

   quickstart/python/Dockerfile

   Ver no GitHub (em inglês)

   # Use the official lightweight Python image.
   # https://hub.docker.com/_/python
   FROM python:3.7-slim
   
   # Copy local code to the container image.
   ENV APP_HOME /app
   WORKDIR $APP_HOME
   COPY . ./
   
   # Install production dependencies.
   RUN pip install Flask gunicorn
   
   # Run the web service on container startup. Here we use the gunicorn
   # webserver, with one worker process and 8 threads.
   # For environments with multiple CPU cores, increase the number of workers
   # to be equal to the cores available.
   CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 app:app
   

   Adicione um arquivo .dockerignore para garantir que os arquivos locais não afetem o processo de criação do contêiner:

   quickstart/python/.dockerignore

   Ver no GitHub (em inglês)

   Dockerfile
   README.md
   *.pyc
   *.pyo
   *.pyd
   __pycache__
   

   Java

   quickstart/java/Dockerfile

   Ver no GitHub (em inglês)

   # Use the official maven/Java 8 image to create a build artifact.
   # https://hub.docker.com/_/maven
   FROM maven:3.5-jdk-8-alpine as builder
   
   # Copy local code to the container image.
   WORKDIR /app
   COPY pom.xml ./
   COPY src ./src/
   
   # Build a release artifact.
   RUN mvn package -DskipTests
   
   # Use AdoptOpenJDK for base image.
   # It's important to use OpenJDK 8u191 or above that has container support enabled.
   # https://hub.docker.com/r/adoptopenjdk/openjdk8
   # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
   FROM adoptopenjdk/openjdk8:jdk8u202-b08-alpine-slim
   
   # Copy the jar to the production image from the builder stage.
   COPY --from=builder /app/target/helloworld-*.jar /helloworld.jar
   
   # Run the web service on container startup.
   CMD ["java","-Djava.security.egd=file:/dev/./urandom","-Dserver.port=${PORT}","-jar","/helloworld.jar"]
   

   C#

   quickstart/dotnet/Dockerfile

   Ver no GitHub (em inglês)

   # Use Microsoft's official lightweight .NET images.
   # https://hub.docker.com/r/microsoft/dotnet
   
   FROM mcr.microsoft.com/dotnet/core/sdk:2.2-alpine AS build
   WORKDIR /app
   
   # Install production dependencies.
   # Copy csproj and restore as distinct layers.
   COPY *.csproj ./
   RUN dotnet restore
   
   # Copy local code to the container image.
   COPY . ./
   
   # Build a release artifact.
   RUN dotnet publish -c Release -o out
   
   # Run the web service on container startup in a lean production image.
   FROM mcr.microsoft.com/dotnet/core/aspnet:2.2-alpine
   WORKDIR /app
   
   COPY --from=build /app/out ./
   CMD ["dotnet", "HelloGKE.dll"]
   

   Adicione um arquivo .dockerignore para garantir que os arquivos locais não afetem o processo de criação do contêiner:

   quickstart/dotnet/.dockerignore

   Ver no GitHub (em inglês)

   Dockerfile
   README.md
   **/obj/
   **/bin/
   

   PHP

   quickstart/php/Dockerfile

   Ver no GitHub (em inglês)

   # Use the official PHP 7.2 image.
   # https://hub.docker.com/_/php
   FROM php:7.2-apache
   
   # Copy local code to the container image.
   COPY index.php /var/www/html/
   
   # Use port 8080 in Apache configuration files.
   RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf
   
   # Configure PHP for development.
   # Switch to the production php.ini for production operations.
   # RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
   # https://hub.docker.com/_/php#configuration
   RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"
   

   Adicione um arquivo .dockerignore para garantir que os arquivos locais não afetem o processo de criação do contêiner:

   quickstart/php/.dockerignore

   Ver no GitHub (em inglês)

   Dockerfile
   README.md
   vendor
   

   Ruby

   quickstart/ruby/Dockerfile

   Ver no GitHub (em inglês)

   # Use the official lightweight Ruby image.
   # https://hub.docker.com/_/ruby
   FROM ruby:2.5-slim
   
   # Install production dependencies.
   WORKDIR /usr/src/app
   COPY Gemfile ./
   RUN bundle install
   
   # Copy local code to the container image.
   COPY . ./
   
   # Run the web service on container startup.
   CMD ["ruby", "./app.rb"]
   

2. Receba seu ID do projeto do Google Cloud:

   gcloud config get-value project
   

   Crie sua imagem de contêiner usando Cloud Build, que é semelhante à execução de docker build e docker push, mas isso acontece no Google Cloud. Substitua project-id pelo ID do Google Cloud:

   gcloud builds submit --tag gcr.io/project-id/helloworld-gke .
   

   A imagem é armazenada no Container Registry.

Como criar um cluster do Kubernetes Engine

O cluster do GKE é um conjunto gerenciado de máquinas virtuais do Compute Engine que é operado como uma única unidade. Neste tutorial, apenas um nó é usado.

1. Crie o cluster. Substitua your-gcp-zone pela zona do Google Cloud em que você quer hospedar seu cluster. Para uma lista completa, consulte Geografia e regiões.

   gcloud container clusters create helloworld-gke \
      --num-nodes 1 \
      --enable-basic-auth \
      --issue-client-certificate \
      --zone your-gcp-zone
   

   Observação: uma região contém uma ou mais zonas. Um nó é criado em cada zona dentro da região quando você usa uma região em vez de uma zona na opção --zone. Por exemplo, us-central1 em vez de us-central1-b.
   Observação: o escopo padrão é definido como --scopes=gke-default. Para uma lista completa de escopos disponíveis, consulte Escopos do OAuth 2.0 para APIs do Google (em inglês).

2. Verifique se você tem acesso ao cluster. O comando a seguir lista os nós no cluster do contêiner que estão em execução e indica que você tem acesso a eles.

   kubectl get nodes
   

   Se ocorrerem erros, consulte o Guia de solução de problemas do Kubernetes (em inglês).

Como fazer implantações no GKE

Para implantar o aplicativo no cluster do GKE que você criou, são necessários dois objetos do Kubernetes.

1. O objeto Deployment (em inglês) para definir o aplicativo
2. O objeto Service (em inglês) para definir como acessar o aplicativo

Implantar um app

O aplicativo tem um servidor de front-end que processa as solicitações da Web. Defina os recursos de cluster necessários para executar o front-end em um novo arquivo chamado deployment.yaml. Eles são conhecidos como Implantação. Use Implantações para criar e atualizar um ReplicaSet (em inglês) e os pods associados.

1. Crie o arquivo deployment.yaml no mesmo diretório dos outros arquivos e copie o conteúdo a seguir, substituindo $GCLOUD_PROJECT pelo ID do projeto do Google Cloud:

   quickstart/deployment.yaml

   Ver no GitHub (em inglês)

   # This file configures the hello-world app which serves public web traffic.
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: helloworld-gke
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: hello
     template:
       metadata:
         labels:
           app: hello
       spec:
         containers:
         - name: hello-app
           # Replace $GCLOUD_PROJECT with your project ID
           image: gcr.io/$GCLOUD_PROJECT/helloworld-gke:latest
           # This app listens on port 8080 for web traffic by default.
           ports:
           - containerPort: 8080
           env:
             - name: PORT
               value: "8080"
   

2. Implante o recurso no cluster:

   kubectl apply -f deployment.yaml
   

3. Acompanhe o status da implantação:

   kubectl get deployments
   

   A implantação é concluída quando todas as implantações AVAILABLE são READY.

   NAME               READY   UP-TO-DATE   AVAILABLE   AGE
   hello-deployment   1/1     1            1           20s
   

   Se a implantação tiver um erro, execute kubectl apply -f deployment.yaml novamente para atualizar a implantação com alterações.

4. Depois que a implantação for concluída, veja os pods criados por ela:

   kubectl get pods
   

Implantar um Service

O objeto Service (em inglês) fornece um único ponto de acesso a um conjunto de pods. É possível acessar um único pod, mas eles são efêmeros, e o acesso só é confiável quando feito usando um endereço de Service. Em seu aplicativo Hello World, o serviço "hello" "define um balanceador de carga (em inglês) para acessar os conjuntos hello-app a partir de um único endereço IP." Este Service é definido no arquivo service.yaml.

1. Crie o arquivo service.yaml no mesmo diretório que seus outros arquivos de origem com o seguinte conteúdo:

   quickstart/service.yaml

   Ver no GitHub (em inglês)

   # The hello service provides a load-balancing proxy over the hello-app
   # pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
   # create an external HTTP load balancer.
   apiVersion: v1
   kind: Service
   metadata:
     name: hello
   spec:
     type: LoadBalancer
     selector:
       app: hello
     ports:
     - port: 80
       targetPort: 8080
   

   Os pods são definidos separadamente do Service que os usa. No Kubernetes, use rótulos para selecionar os pods atendidos por um Service. Com isso, você tem um Service que inclui pods de diferentes conjuntos de réplicas e vários Services que apontam para um pod específico.

2. Crie o Service "Hello World":

   kubectl apply -f service.yaml
   

3. Consiga o endereço IP externo do Service:

   kubectl get services
   

   Pode levar até 60 segundos para alocar o endereço IP. O endereço IP externo é listado na coluna EXTERNAL-IP do serviço hello.

   NAME         TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE
   hello        LoadBalancer   10.22.222.222   35.111.111.11   80:32341/TCP   1m
   kubernetes   ClusterIP      10.22.222.1     <none>          443/TCP        20m
   

Ver um aplicativo implantado

Agora você implantou todos os recursos necessários para executar o aplicativo "Hello World" no GKE. Use o endereço IP externo da etapa anterior para carregar o aplicativo no navegador da Web e executá-lo.

# Example cURL call to your running application on GKE (external IP address of service)
curl 35.111.111.11
Hello World!

Realizar a limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste guia de início rápido, siga estas etapas.

Você é cobrado pelas instâncias do Compute Engine em execução no cluster, bem como pela imagem de contêiner do Container Registry.

Excluir o projeto

A exclusão do projeto do Cloud interrompe o faturamento de todos os recursos usados nesse projeto.

Cuidado: excluir um projeto tem os seguintes efeitos:
• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.
1. No Console do Cloud, acesse a página Gerenciar recursos:

   Acessar a página "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir o cluster e o contêiner

Se quiser manter o projeto, mas excluir apenas os recursos usados neste tutorial, remova o cluster e a imagem.

Para excluir um cluster usando a ferramenta de linha de comando gcloud, execute o comando a seguir:

gcloud container clusters delete helloworld-gke

Observação: para mais informações, consulte a documentação em Como excluir um cluster.

Para excluir uma imagem de um dos repositórios do Container Registry, execute o comando a seguir:

gcloud container images delete gcr.io/project-id/helloworld-gke

Observação: para mais informações, consulte a documentação em Como gerenciar imagens.

A seguir

Para mais informações sobre o Kubernetes, consulte:

• Saiba mais sobre como criar clusters.
• Saiba mais sobre o Kubernetes.
• Leia a documentação de referência de kubectl (em inglês).

Para mais informações sobre como fazer implantações no GKE, consulte:

• Saiba como empacotar, hospedar e implantar um aplicativo simples de servidor da Web.
• Implante um aplicativo de livro de visitas com Redis e PHP.
• Implante um aplicativo com estado do WordPress com armazenamento permanente e MySQL.
• Como configurar o Cloud Run no GKE.

Para mais informações sobre como fazer implantações no GKE diretamente do seu ambiente de desenvolvimento integrado com o Cloud Code, consulte:

• Cloud Code para VS Code
• Cloud Code para IntelliJ