Guia de início rápido

Neste guia de início rápido, mostramos como implantar um aplicativo em contêineres com o Kubernetes Engine.

Antes de começar

Siga estas etapas para ativar a Google Kubernetes Engine API:
  1. Acesse a página do Kubernetes Engine no Console do Google Cloud Platform.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode demorar alguns minutos.
  4. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

Como escolher um shell

Para concluir este guia de início rápido, você pode usar o Google Cloud Shell ou um shell local.

O Google Cloud Shell é um ambiente de shell para gerenciar recursos hospedados no Google Cloud Platform (GCP). O Cloud Shell vem pré-instalado com as ferramentas de linha de comando gcloud e kubectl. gcloud fornece a interface de linha de comando principal para o GCP, e kubectl fornece a interface de linha de comando para executar comandos em clusters do Kubernetes.

Se você preferir usar o shell local, instale as ferramentas de linha de comando gcloud e kubectl em seu ambiente.

Cloud Shell

Para iniciar o Cloud Shell, execute as seguintes etapas:

  1. Acesse o Console do Google Cloud Platform.

    Console do Google Cloud Platform

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

Uma sessão do Cloud Shell é aberta dentro de um frame na parte inferior do console. Use esse shell para executar os comandos gcloud e kubectl.

Shell local

Para instalar gcloud e kubectl, execute as seguintes etapas:

  1. Instale o Google Cloud SDK, que contém a ferramenta de linha de comando gcloud.
  2. Depois de instalar o Cloud SDK, instale a ferramenta de linha de comando kubectl executando o seguinte comando:

    gcloud components install kubectl
    

Como definir as configurações padrão para gcloud

Antes de começar, use o gcloud para definir duas configurações padrão: o projeto e a zona de computação.

A definição dessas configurações padrão facilita a execução de comandos do gcloud, uma vez que o gcloud requer que você especifique o projeto e a zona de computação em que quer trabalhar. Você também pode especificar essas configurações ou substituir as configurações padrão passando sinalizações operacionais, como --project, --zone e --cluster, para comandos do gcloud.

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

Como definir um projeto padrão

O código do projeto é o identificador exclusivo dele. Ao criar um projeto pela primeira vez, você pode usar o código gerado automaticamente ou um próprio.

Para definir um projeto padrão, execute o seguinte comando do Cloud Shell:

gcloud config set project [PROJECT_ID]

Substitua [PROJECT_ID] pelo código do seu projeto.

Como definir uma zona de computação padrão

A zona de computação é um local regional aproximado que armazena os clusters e os recursos. Por exemplo, us-west1-a é uma zona na região us-west.

Para definir uma zona de computação padrão, execute o seguinte comando:

gcloud config set compute/zone [COMPUTE_ZONE]

em que [COMPUTE_ZONE] é a zona de computação geográfica desejada, como us-west1-a.

Como criar um cluster do Kubernetes Engine

Um cluster consiste em pelo menos uma máquina mestre do cluster e várias máquinas de trabalhador chamadas nodes. Os nodes são instâncias de máquinas virtuais (VM, na sigla em inglês) do Compute Engine que executam os processos do Kubernetes necessários para torná-los parte do cluster. Você implanta aplicativos nos clusters, e os aplicativos são executados nos nodes.

Para criar um cluster, execute o seguinte comando:

gcloud container clusters create [CLUSTER_NAME]

em que [CLUSTER_NAME] é o nome que você escolhe para o cluster.

Receber credenciais de autenticação para o cluster

Depois de criar o cluster, você precisará receber credenciais de autenticação para interagir com ele.

Para fazer autenticação no cluster, execute o seguinte comando:

gcloud container clusters get-credentials [CLUSTER_NAME]

Como implantar um aplicativo no cluster

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

O Kubernetes Engine usa objetos do 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.

Como criar a implantação

Para rodar o hello-app em seu cluster, execute o seguinte comando:

kubectl run hello-server --image gcr.io/google-samples/hello-app:1.0 --port 8080

O comando kubectl run do Kubernetes cria uma nova implantação chamada hello-server. O pod da implantação executa a imagem do hello-app no respectivo contêiner.

Nesse comando:

  • --image especifica uma imagem de contêiner para implantar. Nesse caso, o comando extrai a imagem de exemplo de um intervalo do Google Container Registry, gcr.io/google-samples/hello-app. :1.0 indica a versão de imagem específica para extrair. Se uma versão não for especificada, a versão mais recente será usada;
  • --port especifica a porta que o contêiner expõe.

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"

Quando você passa a sinalização --type="LoadBalancer", um balanceador de carga do Compute Engine é criado para o contêiner. 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 o serviço hello-server executando kubectl get:

    kubectl get service hello-server
    

    No resultado desse comando, copie o endereço IP externo do serviço da coluna EXTERNAL IP.

  2. Veja o aplicativo no navegador da Web usando o endereço IP externo com a porta exposta:

    http://[EXTERNAL_IP]:8080
    

Você acabou de implantar um aplicativo em contêineres no Kubernetes Engine.

Limpar

Para evitar cobranças na conta do Google Cloud Platform pelo uso dos recursos neste guia de início rápido, siga estas etapas:

  1. Exclua o serviço do aplicativo executando kubectl delete:

    kubectl delete service hello-server
    
  2. Exclua o cluster executando gcloud container clusters delete:

    gcloud container clusters delete [CLUSTER_NAME]
    

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

hello-app é um aplicativo de servidor da Web simples composto por dois arquivos: main.go e Dockerfile.

hello-app é empacotado como imagem de contêiner do Docker. As imagens de contêiner são armazenadas em qualquer registro de imagens do Docker, como o Google Container Registry. Hospedamos o hello-app em um intervalo do Container Registry chamado gcr.io/google-samples/hello-app.

main.go

main.go é uma implementação de servidor da Web escrita na linguagem de programação Go. O servidor responde a qualquer solicitação HTTP com a mensagem “Hello, world!” (Olá, mundo!).

package main

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

func main() {
	port := "8080"
	if fromEnv := os.Getenv("PORT"); fromEnv != "" {
		port = fromEnv
	}

	server := http.NewServeMux()
	server.HandleFunc("/", hello)
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, server))
}

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

No Dockerfile, há uma descrição da imagem que você quer que o Docker crie, com todos os recursos e as dependências, e uma especificação sobre qual porta de rede o aplicativo deve expor. Para saber mais sobre como esse arquivo funciona, consulte a referência do Dockerfile na documentação do Docker.

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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine