Este tutorial mostra como implementar uma aplicação Web contentorizada num cluster do Google Kubernetes Engine (GKE).
Esta página destina-se a operadores e programadores que preparam e configuram recursos na nuvem, e implementam apps e serviços. Para saber mais sobre as funções comuns e as tarefas de exemplo referenciadas no Google Cloud conteúdo, consulte o artigoFunções e tarefas comuns do utilizador do GKE.
Antes de ler esta página, certifique-se de que conhece o Kubernetes.
Objetivos
- Empacote uma aplicação Web de amostra numa imagem do Docker.
- Carregue a imagem do Docker para o Artifact Registry.
- Crie um cluster do GKE.
- Implemente a app de exemplo no cluster.
- Faça a gestão do dimensionamento automático para a implementação.
- Exponha a app de exemplo à Internet.
- Implemente uma nova versão da app de exemplo.
Custos
Neste documento, usa os seguintes componentes faturáveis do Google Cloud:
Para gerar uma estimativa de custos com base na sua utilização projetada,
use a calculadora de preços.
Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.
Antes de começar
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator
(
roles/resourcemanager.projectCreator
), which contains theresourcemanager.projects.create
permission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (
roles/serviceusage.serviceUsageAdmin
), which contains theserviceusage.services.enable
permission. Learn how to grant roles. -
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator
(
roles/resourcemanager.projectCreator
), which contains theresourcemanager.projects.create
permission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (
roles/serviceusage.serviceUsageAdmin
), which contains theserviceusage.services.enable
permission. Learn how to grant roles. - Aceda à Google Cloud consola.
Clique no botão Ativar Cloud Shell
na parte superior da janela da Google Cloud consola.
É aberta uma sessão do Cloud Shell num novo frame na parte inferior da Google Cloud consola e é apresentado um comando.
Defina a variável de ambiente
PROJECT_ID
para o Google Cloud ID do projeto (PROJECT_ID
). Vai usar esta variável de ambiente quando criar a imagem do contentor e a enviar para o seu repositório.export PROJECT_ID=PROJECT_ID
Confirme que a variável de ambiente
PROJECT_ID
tem o valor correto:echo $PROJECT_ID
Defina o ID do projeto para a CLI Google Cloud:
gcloud config set project $PROJECT_ID
Saída:
Updated property [core/project].
Crie o repositório
hello-repo
com o seguinte comando:gcloud artifacts repositories create hello-repo \ --repository-format=docker \ --location=REGION \ --description="Docker repository"
Substitua
REGION
por uma região para o repositório, comous-west1
. Para ver uma lista de localizações disponíveis, execute o comando:gcloud artifacts locations list
Transfira o
hello-app
código-fonte e o Dockerfile executando os seguintes comandos:git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/quickstarts/hello-app
Crie e etiquete a imagem de Docker para
hello-app
:docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
Este comando indica ao Docker para criar a imagem usando o
Dockerfile
no diretório atual, guardá-la no seu ambiente local e etiquetá-la com um nome, comous-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1
. A imagem é enviada para o Artifact Registry na secção seguinte.- A variável
PROJECT_ID
associa a imagem do contentor aohello-repo
repositório no seu Google Cloud projeto. - O prefixo
us-west1-docker.pkg.dev
refere-se ao Artifact Registry, anfitrião regional do seu repositório.
- A variável
Execute o comando
docker images
para verificar se a compilação foi bem-sucedida:docker images
Saída:
REPOSITORY TAG IMAGE ID CREATED SIZE us-west1-docker.pkg.dev/my-project/hello-repo/hello-app v1 25cfadb1bf28 10 seconds ago 54 MB
Adicione associações de políticas IAM à sua conta de serviço:
gcloud artifacts repositories add-iam-policy-binding hello-repo \ --location=REGION \ --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \ --role="roles/artifactregistry.reader"
Substitua
PROJECT_NUMBER
pelo número do projeto do seu projeto.Teste a imagem do contentor com o motor Docker local:
docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
Clique no botão Pré-visualização na Web
e, de seguida, selecione o número da porta
8080
. O GKE abre o URL de pré-visualização no respetivo serviço de proxy numa nova janela do navegador.Configure a ferramenta de linha de comandos do Docker para autenticar no Artifact Registry:
gcloud auth configure-docker REGION-docker.pkg.dev
Envie a imagem do Docker que acabou de criar para o repositório:
docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
Defina a região do Compute Engine:
gcloud config set compute/region REGION
Para clusters zonais padrão, defina uma zona do Compute Engine mais próxima do repositório do Artifact Registry.
Crie um cluster com o nome
hello-cluster
:gcloud container clusters create-auto hello-cluster
Demora alguns minutos para que o cluster do GKE seja criado e a respetiva integridade seja verificada. Para executar este tutorial num cluster padrão do GKE, use o comando
gcloud container clusters create
.Na Google Cloud consola, aceda à página Criar um cluster do Autopilot.
No campo Nome, introduza o nome
hello-cluster
.Selecione uma região do Compute Engine na lista pendente Região, como
us-west1
.Clique em Criar.
Aguarde a criação do cluster. Quando o cluster estiver pronto, é apresentada uma marca de verificação junto ao nome do cluster.
Certifique-se de que tem ligação ao cluster do GKE.
gcloud container clusters get-credentials hello-cluster
Crie uma implementação do Kubernetes para a sua
hello-app
imagem do Docker.kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
Defina o número de réplicas de implementação de base como 3.
kubectl scale deployment hello-app --replicas=3
Crie um recurso
HorizontalPodAutoscaler
para a sua implementação.kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
Para ver os pods criados, execute o seguinte comando:
kubectl get pods
Saída:
NAME READY STATUS RESTARTS AGE hello-app-784d7569bc-hgmpx 1/1 Running 0 90s hello-app-784d7569bc-jfkz5 1/1 Running 0 90s hello-app-784d7569bc-mnrrl 1/1 Running 0 95s
Aceda à página Workloads na Google Cloud consola.
Clique em add_box Implementar.
Na secção Especificar contentor, selecione Imagem de contentor existente.
No campo Caminho da imagem, clique em Selecionar.
No painel Selecionar imagem do contentor, selecione a imagem
hello-app
que enviou para o Artifact Registry e clique em Selecionar.Na secção Contentor, clique em Concluído e, de seguida, em Continuar.
Na secção Configuração, em Etiquetas, introduza
app
para Chave ehello-app
para Valor.Em YAML de configuração, clique em Ver YAML. Esta ação abre um ficheiro de configuração YAML que representa os dois recursos da API Kubernetes prestes a serem implementados no seu cluster: uma implementação e um
HorizontalPodAutoscaler
para essa implementação.Clique em Fechar e, de seguida, em Implementar.
Quando os pods de implementação estiverem prontos, é apresentada a página Detalhes da implementação.
Em Managed pods (Pods geridos), repare nos três pods em execução para a
hello-app
implementação.Use o comando
kubectl expose
para gerar um serviço Kubernetes para a implementaçãohello-app
:kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
Aqui, a flag
--port
especifica o número da porta configurado no equilibrador de carga e a flag--target-port
especifica o número da porta em que o contentorhello-app
está a escutar.Execute o seguinte comando para obter os detalhes do serviço para
hello-app-service
:kubectl get service
Saída:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-app-service 10.3.251.122 203.0.113.0 80:30877/TCP 10s
Copie o endereço
EXTERNAL_IP
para a área de transferência (por exemplo:203.0.113.0
).Aceda à página Workloads na Google Cloud consola.
Clique em hello-app.
Na página Deployment details (Detalhes da implementação), clique em list Actions > Expose (Ações > Expor).
Na caixa de diálogo Expor, defina a Porta de destino como
8080
. Esta é a porta que o contentorhello-app
escuta.Na lista pendente Tipo de serviço, selecione Equilibrador de carga.
Clique em Expor para criar um serviço Kubernetes para
hello-app
.Quando o balanceador de carga estiver pronto, é apresentada a página Detalhes do serviço.
Desloque a página para baixo até ao campo Pontos finais externos e copie o endereço IP.
Regresse ao Cloud Shell, onde clonou o código fonte da app hello e o Dockerfile. Atualize a função
hello()
no ficheiromain.go
para comunicar a nova versão2.0.0
.Crie e etiquete uma nova imagem do
hello-app
Docker.docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .
Envie a imagem para o Artifact Registry.
docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
Aplique uma atualização contínua à
hello-app
implementação existente com uma atualização de imagem através do comandokubectl set image
:kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
Veja os pods em execução com a imagem
v1
parar e os novos pods em execução com a imagemv2
iniciar.watch kubectl get pods
Saída:
NAME READY STATUS RESTARTS AGE hello-app-89dc45f48-5bzqp 1/1 Running 0 2m42s hello-app-89dc45f48-scm66 1/1 Running 0 2m40s
Num separador separado, navegue novamente para o
hello-app-service
IP externo. Agora, deve ver oVersion
definido como2.0.0.
Aceda à página Workloads na Google Cloud consola.
Clique em hello-app.
Na página Detalhes da implementação, clique em list Ações > Atualização contínua.
Na caixa de diálogo Atualização contínua, defina o campo Imagem de hello-app como
REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2
.Clique em Atualizar.
Na página Detalhes da implementação, inspecione a secção Revisões ativas. Agora, deve ver duas revisões, 1 e 2. A revisão 1 corresponde à implementação inicial que criou anteriormente. A revisão 2 é a atualização incremental que acabou de iniciar.
Após alguns momentos, atualize a página. Em Pods geridos, todas as réplicas de
hello-app
correspondem agora à revisão 2.Num separador separado, navegue novamente para o endereço IP do serviço que copiou. O
Version
deve ser2.0.0.
Eliminar o serviço: esta ação anula a atribuição do Cloud Load Balancer criado para o seu serviço:
kubectl delete service hello-app-service
Elimine o cluster: esta ação elimina os recursos que compõem o cluster, como as instâncias de cálculo, os discos e os recursos de rede:
gcloud container clusters delete hello-cluster
Elimine as suas imagens de contentores: esta ação elimina as imagens Docker que enviou para o Artifact Registry.
gcloud artifacts docker images delete \ REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \ --delete-tags --quiet gcloud artifacts docker images delete \ REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \ --delete-tags --quiet
Saiba mais sobre os preços do GKE e use a calculadora de preços para estimar os custos.
Leia o tutorial Equilibradores de carga, que demonstra configurações avançadas de equilíbrio de carga para aplicações Web.
Configure um IP estático e um nome de domínio para a sua aplicação.
Explore outros tutoriais do Kubernetes Engine.
Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.
Ativar Cloud Shell
A Cloud Shell vem pré-instalada com as ferramentas de linha de comandos gcloud
, docker
e kubectl
que são usadas neste tutorial.
Crie um repositório
Neste tutorial, armazena uma imagem no Artifact Registry e implementa-a a partir do registo. Para este início rápido, vai criar um repositório com o nome hello-repo
.
Crie a imagem do hello-app
Docker
Neste tutorial, implementa uma aplicação Web
de exemplo denominada hello-app
, um servidor Web escrito
em Go que responde a todos os pedidos com a mensagem
Hello, World!
na porta 8080.
O GKE aceita imagens Docker como o formato de implementação de aplicações.
Antes de implementar o hello-app
no GKE, tem de criar um pacote do código fonte do hello-app
como uma imagem do Docker.
Para criar uma imagem do Docker, precisa de código-fonte e de um Dockerfile. Um Dockerfile contém instruções sobre como a imagem é criada.
(Opcional) Execute o contentor Docker localmente
Envie a sua imagem de Docker para o Artifact Registry
Tem de carregar a imagem do contentor para um registo para que o cluster do GKE possa transferir e executar a imagem do contentor. Neste tutorial, vai armazenar o seu contentor no Artifact Registry.
Crie um cluster do GKE
Agora que a imagem do Docker está armazenada no Artifact Registry, crie um cluster do GKE para executar o hello-app
. Um cluster do GKE consiste num conjunto de instâncias de VM do Compute Engine
que executam o Kubernetes, o sistema de orquestração de clusters de código aberto
que alimenta o GKE.
Cloud Shell
Consola
Implemente o hello-app
no GKE
Já tem tudo pronto para implementar a imagem do Docker que criou no seu cluster do GKE.
O Kubernetes representa as aplicações como Pods, que são unidades escaláveis que contêm um ou mais contentores. O Pod é a unidade implementável mais pequena no Kubernetes. Normalmente, implementa os pods como um conjunto de réplicas que podem ser dimensionadas e distribuídas em conjunto no seu cluster. Uma forma de implementar um conjunto de réplicas é através de uma implementação do Kubernetes.
Nesta secção, cria uma implementação do Kubernetes para executar o hello-app
no seu cluster. Esta implementação tem réplicas (pods). Um pod de implementação contém apenas
um contentor: a imagem do hello-app
Docker.
Também cria um recurso HorizontalPodAutoscaler que dimensiona o número de pods de 3 para um número entre 1 e 5, com base na carga da CPU.
Cloud Shell
Consola
Exponha a app à Internet
Embora os pods tenham endereços IP atribuídos individualmente, só é possível aceder a esses IPs a partir do interior do cluster. Além disso, os pods do GKE são concebidos para serem temporários, iniciando ou parando com base nas necessidades de escalabilidade. Além disso, quando um pod falha devido a um erro, o GKE volta a implementar automaticamente esse pod, atribuindo um novo endereço IP do pod de cada vez.
Isto significa que, para qualquer implementação, o conjunto de endereços IP correspondente ao conjunto ativo de pods é dinâmico. Precisamos de uma forma de 1) agrupar os pods num nome de anfitrião estático e 2) expor um grupo de pods fora do cluster à Internet.
Os serviços do Kubernetes resolvem ambos os problemas.
Os serviços agrupam os pods
num endereço IP estático, acessível a partir de qualquer pod no cluster.
O GKE também atribui um nome de anfitrião DNS
a esse IP estático. Por exemplo, hello-app.default.svc.cluster.local
.
O tipo de serviço predefinido no GKE chama-se ClusterIP, em que o serviço recebe um endereço IP acessível apenas a partir do interior do cluster.
Para expor um serviço do Kubernetes fora do cluster, crie um serviço do
tipo LoadBalancer
.
Este tipo de serviço gera um IP do balanceador de carga externo para um conjunto de pods, acessível através da Internet.
Nesta secção, expõe a hello-app
implementação à Internet através de um serviço do tipo LoadBalancer
.
Cloud Shell
Consola
Agora que os hello-app
pods estão expostos à Internet através de um serviço Kubernetes,
pode abrir um novo separador do navegador e navegar para o endereço IP do serviço que copiou
para a área de transferência. É apresentada uma mensagem Hello, World!
, juntamente com um campo Hostname
. O Hostname
corresponde a um dos três hello-app
pods que publicam o seu pedido HTTP no seu navegador.
Implemente uma nova versão do hello-app
Nesta secção, atualiza o hello-app
para uma nova versão criando e implementando uma nova imagem do Docker no seu cluster do GKE.
A atualização contínua do Kubernetes permite-lhe atualizar as suas implementações sem períodos de inatividade. Durante uma atualização contínua, o cluster do GKE substitui incrementalmente os hello-app
pods existentes por pods que contêm a imagem do Docker para a nova versão.
Durante a atualização, o serviço de balanceamento de carga encaminha o tráfego apenas para os pods disponíveis.
Agora, já pode atualizar a sua implementação do hello-app
Kubernetes para usar uma nova imagem do Docker.
Cloud Shell
Consola
Limpar
Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.
O que se segue?
Experimente
Se está a usar o Google Cloud pela primeira vez, crie uma conta para avaliar o desempenho do GKE em cenários reais. Os novos clientes também recebem 300 USD em créditos gratuitos para executar, testar e implementar cargas de trabalho.
Experimente o GKE gratuitamente