Guia de início rápido

Neste guia de início rápido, você implanta um aplicativo em contêiner simples 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.

Neste guia de início rápido, pressupomos que haja uma compreensão básica do Kubernetes.

Você pode seguir as etapas nesta página ou usar este guia de início rápido como um laboratório do Google Cloud Training.

Use-o com um laboratório

Antes de começar

Siga estas etapas para ativar a API do Kubernetes Engine:

1. Acesse a página do Kubernetes Engine no Console do Google Cloud.
2. Crie ou selecione um projeto.
3. Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.

4. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

Requisitos de cota

Para concluir este guia de início rápido, você precisa da cota disponível:

• 1 CPU do Compute Engine na região do cluster.
• 1 endereço IP em uso.

Para verificar sua cota disponível, use o Console do Cloud.

Como escolher um shell

Para concluir este guia de início rápido, use o Cloud Shell ou o shell local.

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 gcloud e kubectl. A ferramenta 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.

Se preferir usar seu shell local, instale as ferramentas gcloud e kubectl em seu ambiente.

Cloud Shell

Para iniciar o Cloud Shell, execute os seguintes passos:

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.

Shell local

Para instalar gcloud e kubectl, execute os seguintes passos:

1. Instale o SDK do Cloud , que inclui a ferramenta de linha de comando gcloud.

2. Depois de instalar o SDK do Cloud, execute o comando a seguir para instalar a ferramenta de linha de comando kubectl:

   gcloud components install kubectl

Como definir configurações padrão para a ferramenta gcloud

Use a ferramenta gcloud para definir duas configurações padrão: projeto e zona do Compute.

Seu projeto tem um ID do projeto que é seu identificador exclusivo. Ao criar um projeto pela primeira vez, é possível usar o ID do projeto gerado automaticamente ou criar um próprio.

Sua zona do Compute é um local na região onde estão os clusters e seus recursos. Por exemplo, us-west1-a é uma zona na região us-west.

O ajuste dessas configurações padrão facilita a execução dos comandos gcloud, porque gcloud requer que você especifique o projeto e a zona do Compute em que quer trabalhar. Também é possível especificar essas configurações ou modificar as configurações padrão com sinalizações, como --project, --zone e --cluster, nos comandos gcloud.

Quando você cria os recursos do GKE depois de configurar o projeto e a zona do Compute padrão, os recursos são criados automaticamente nesse projeto e nessa zona.

Observação: a ferramenta gcloud retorna um erro se essas configurações não estiverem configuradas ou não forem especificadas.

Como definir um projeto padrão

Execute o seguinte comando, substituindo project-id pelo ID do projeto:

gcloud config set project project-id

Como definir uma zona ou região do Compute padrão

Dependendo do modo de operação escolhido para usar no GKE, especifique uma zona ou região padrão. Se você usar o modo padrão, o cluster será zonal (neste tutorial). Por isso, defina a zona do Compute padrão. Se você usar o modo Autopilot, o cluster será regional. Portanto, defina a região do Compute padrão.

Padrão

Execute o seguinte comando, substituindo compute-zone por sua zona do Compute, como us-west1-a:

gcloud config set compute/zone compute-zone

Piloto automático

Execute o seguinte comando, substituindo compute-region pela região do Compute, como us-west1:

gcloud config set compute/region compute-region

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áquinas virtuais (VM) do Compute Engine que executam os processos do Kubernetes necessários para torná-los parte do cluster. Implante aplicativos nos clusters para que eles sejam executados nos nós.

Padrão

O comando a seguir cria um cluster de um nó. Substitua cluster-name pelo nome do cluster:

gcloud container clusters create cluster-name --num-nodes=1

Piloto automático

O comando a seguir cria um cluster do Autopilot. Substitua cluster-name pelo nome do cluster:

 gcloud container clusters create-auto cluster-name

Observação: a criação de um cluster pode levar vários 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 cluster-name

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

Como implantar um aplicativo no cluster

Agora que você criou um cluster, implante um aplicativo em contêiner 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 Implantação para fazer esse processo em aplicativos sem estado, como servidores da Web. Os objetos Service definem as regras e o balanceamento de carga para acessar seu aplicativo pela Internet.

Como criar a implantação

Para executar hello-app no cluster, execute o seguinte comando:

kubectl create deployment hello-server --image=gcr.io/google-samples/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 bucket do Container Registry: gcr.io/google-samples/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 mais recente será usada.

Observação: neste tutorial, você usa uma imagem de contêiner do Container Registry. O Google Cloud também oferece um serviço universal de gerenciamento de pacotes, o Artifact Registry. O Artifact Registry é compatível com contêineres e outros formatos, além de oferecer maior flexibilidade e controle sobre os artefatos. Saiba mais sobre as diferenças entre esses registros na comparação de recursos.

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

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

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:

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 cluster-name

   Observação: se você não configurou uma zona ou região padrão, transmita a região do cluster (--region=region). ou sinalizações da zona (--zone=zone) para a ferramenta gcloud.

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 Container Registry. Hospedamos hello-app em um bucket do Container Registry chamado gcr.io/google-samples/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!".

hello-app/main.go

Ver no GitHub

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.

hello-app/Dockerfile

Ver no GitHub

FROM golang:1.8-alpine
ADD . /go/src/hello-app
RUN go install hello-app

FROM alpine:latest
COPY --from=0 /go/bin/hello-app .
ENV PORT 8080
CMD ["./hello-app"]

Próximas etapas

• Saiba mais sobre como criar clusters.
• Saiba mais sobre o Kubernetes.
• Leia a documentação de referência do kubectl.
• 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.