Implantar um app em um cluster do GKE

Implantar um app em um cluster do GKE

Autopilot Standard

---

Neste guia de início rápido, você implanta um aplicativo conteinerizado para servidor da Web em um cluster do Google Kubernetes Engine (GKE). Você aprenderá como criar um cluster e como implantar o aplicativo nesse cluster para que ele possa ser acessado por usuários.

Antes de ler esta página, você precisa ter familiaridade com o Kubernetes.

Antes de começar

Siga estas etapas para ativar a API do Kubernetes Engine:

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

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Artifact Registry and Google Kubernetes Engine APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Artifact Registry and Google Kubernetes Engine APIs.

   Enable the APIs

Iniciar o Cloud Shell

Neste tutorial, você usará o Cloud Shell, um ambiente de shell para gerenciar recursos hospedados no Google Cloud.

O Cloud Shell vem pré-instalado com as ferramentas de linha de comando CLI do Google Cloud e kubectl. A CLI gcloud fornece a principal interface de linha de comando do Google Cloud e kubectl fornece a principal interface de linha de comando para executar comandos em clusters do Kubernetes.

Inicie o Cloud Shell:

1. Acesse o console do Google Cloud.

   Console do Google Cloud

2. No canto superior direito do console, clique no botão Ativar Cloud Shell:

Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console. Use esse shell para executar os comandos gcloud e kubectl. Antes de executar comandos, defina o projeto padrão na Google Cloud CLI usando o seguinte comando:

gcloud config set project PROJECT_ID

Substitua PROJECT_ID pelo ID do projeto.

Crie um cluster do GKE

Um cluster consiste em pelo menos uma máquina de plano de controle de clusters e várias máquinas de worker chamadas de nós. Os nós são instâncias de máquina virtual (VM) do Compute Engine que executam os processos do Kubernetes necessários para integrá-los ao cluster. Implante aplicativos nos clusters para que eles sejam executados nos nós.

Crie um cluster do Autopilot chamado hello-cluster:

gcloud container clusters create-auto hello-cluster \
    --location=us-central1

Observação: a criação do cluster pode demorar alguns minutos.

Receber credenciais de autenticação para o cluster

Depois de criar o cluster, você precisará das credenciais de autenticação para interagir com o cluster:

gcloud container clusters get-credentials hello-cluster \
    --location us-central1

Esse comando configura kubectl para usar o cluster que você criou.

Implantar um aplicativo no cluster

Agora que criou um cluster, você pode implantar um aplicativo conteinerizado nele. Para este guia de início rápido, implante nosso exemplo de aplicativo da Web, hello-app.

O GKE usa objetos Kubernetes para criar e gerenciar os recursos do cluster. O Kubernetes fornece o objeto de implantação para implantar aplicativos sem estado como servidores da Web. Os objetos de serviço definem as regras e o balanceamento de carga para acessar seu aplicativo pela Internet.

Criar a implantação

Para executar hello-app no cluster, você precisa implantar o aplicativo executando o seguinte comando:

kubectl create deployment hello-server \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Este comando do Kubernetes, kubectl create deployment, cria uma implantação chamada hello-server. O pod da implantação executa a imagem de contêiner hello-app.

Nesse comando:

• --image especifica uma imagem de contêiner a ser implantada. Nesse caso, o comando extrai a imagem de exemplo de um repositório do Artifact Registry, us-docker.pkg.dev/google-samples/containers/gke/hello-app. :1.0 indica a versão da imagem específica a ser extraída. Se você não especificar uma versão, a imagem com a tag latest padrão será usada.

Expor a implantação

Após a implantação do aplicativo, você precisará expô-lo na Internet para que os usuários possam acessá-lo. Você pode expor seu aplicativo criando um serviço, um recurso do Kubernetes que expõe seu aplicativo ao tráfego externo.

Para expor seu aplicativo, execute o seguinte comando kubectl expose:

kubectl expose deployment hello-server \
    --type LoadBalancer \
    --port 80 \
    --target-port 8080

Passar na sinalização --type LoadBalancer cria um balanceador de carga do Compute Engine para seu contêiner. A sinalização --port inicializa a porta pública 80 na Internet e a sinalização --target-port encaminha o tráfego para a porta 8080 do aplicativo.

Os balanceadores de carga são cobrados de acordo com os preços estabelecidos do Compute Engine.

Inspecionar e ver o aplicativo

1. Inspecione os pods em execução usando kubectl get pods:

   kubectl get pods
   

   Você verá um pod hello-server em execução no cluster.

2. Use kubectl get service para inspecionar serviço hello-server:

   kubectl get service hello-server
   

   Na saída desse comando, copie o endereço IP externo do serviço da coluna EXTERNAL-IP.

   Observação: talvez você precise aguardar vários minutos até que o endereço IP externo do serviço seja preenchido. Se o IP externo do aplicativo for <pending>, execute kubectl get novamente.

3. Use o endereço IP externo com a porta exposta a seguir para ver o aplicativo pelo navegador da Web:

   http://EXTERNAL_IP
   

Você acabou de implantar um aplicativo da Web em contêineres no GKE.

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

1. Execute kubectl delete para excluir o serviço do aplicativo:

   kubectl delete service hello-server
   

   Esse comando exclui o balanceador de carga do Compute Engine que você criou quando expôs a implantação.

2. Execute gcloud container clusters delete para excluir seu cluster:

   gcloud container clusters delete hello-cluster \
       --location us-central1
   

Opcional: revisão de código hello-app

hello-app é um aplicativo simples de servidor da Web que consiste em dois arquivos: main.go e Dockerfile.

hello-app é empacotado como uma imagem de contêiner do Docker. As imagens de contêiner são armazenadas em qualquer registro de imagens do Docker, como o Artifact Registry. Hospedamos hello-app em um repositório do Artifact Registry em us-docker.pkg.dev/google-samples/containers/gke/hello-app.

main.go

main.go é uma implementação de servidor da Web escrita em Linguagem de programação Go. O servidor responde a qualquer solicitação HTTP com a mensagem "Hello, world!".

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Dockerfile

Dockerfile descreve a imagem que você quer que o Docker crie, com todos os recursos e dependências, além de especificar qual porta de rede o aplicativo deve expôr. Para mais informações sobre como esse arquivo funciona, consulte a referência do Dockerfile na documentação do Docker.

FROM golang:1.21.0 as builder
WORKDIR /app
RUN go mod init hello-app
COPY *.go ./
RUN CGO_ENABLED=0 GOOS=linux go build -o /hello-app

FROM gcr.io/distroless/base-debian11
WORKDIR /
COPY --from=builder /hello-app /hello-app
ENV PORT 8080
USER nonroot:nonroot
CMD ["/hello-app"]

A seguir

• Saiba mais sobre como criar clusters.
• Saiba mais sobre o Kubernetes.
• Saiba como empacotar, hospedar e implantar um aplicativo simples de servidor da Web.
• Implante um aplicativo do Kubernetes com o Cloud Code para VS Code ou o Cloud Code para IntelliJ.
• Saiba como reformular aplicativos Linux para contêineres.

Faça um teste

Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho do GKE em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação sem custos do GKE