Início rápido para Go no ambiente flexível do App Engine

Neste guia de início rápido, você aprenderá a criar um pequeno aplicativo do App Engine que exibe uma mensagem curta.

Antes de começar

Antes de executar e implantar este início rápido, instale o SDK do Cloud e, em seguida, configure um projeto do GCP para o App Engine:

  1. Faça o download e instale o SDK do Cloud:

    Fazer o download do SDK

    Observação: se o SDK do Cloud já estiver instalado, atualize-o executando o seguinte comando:

    gcloud components update
    
  2. Crie o novo projeto:

    gcloud projects create [YOUR_PROJECT_NAME] --set-as-default
    

    Verifique se o projeto foi criado:

    gcloud projects describe [YOUR_PROJECT_NAME]
    

    Você vê detalhes do projeto parecidos com o seguinte:

    createTime: year-month-hour
    lifecycleState: ACTIVE
    name: project-name
    parent:
    id: '433637338589'
    type: organization
    projectId: project-name-id
    projectNumber: 499227785679
    
  3. Inicialize o aplicativo do App Engine com seu projeto e escolha a região:

    gcloud app create --project=[YOUR_PROJECT_NAME]
    

    Quando solicitado, selecione a região em que o aplicativo do App Engine será armazenado.

  4. Verifique se o faturamento está ativado no projeto. Uma conta de faturamento precisa estar vinculada ao projeto para que o aplicativo seja implantado no App Engine.

    Ativar faturamento

  5. Instale os seguintes pré-requisitos:

    • Execute o seguinte comando para instalar o componente do gcloud, que inclui a extensão do App Engine para Go:

      gcloud components install app-engine-go
      

Locais do App Engine

Como o App Engine é regional, a infraestrutura de execução dos aplicativos está em uma determinada região e é gerenciada pelo Google para que esteja disponível de modo redundante em todas as zonas dessa região.

Os seus requisitos de latência, disponibilidade ou durabilidade são os principais fatores considerados para selecionar a região em que os aplicativos serão executados. Em geral, você escolhe a região mais próxima dos usuários do app. No entanto, pense também no local dos outros produtos e serviços do GCP utilizados pelo app. Se você usa os serviços em vários locais, a latência e o preço do app podem ser afetados.

O App Engine está disponível nas seguintes regiões:

  • northamerica-northeast1 (Montreal)
  • us-central (Iowa)
  • us-west2 (Los Angeles)
  • us-east1 (Carolina do Sul)
  • us-east4 (Virgínia do Norte)
  • southamerica-east1 (São Paulo)
  • europe-west (Bélgica)
  • europe-west2 (Londres)
  • europe-west3 (Frankfurt)
  • asia-northeast1 (Tóquio)
  • asia-east2 (Hong Kong)
  • asia-south1 (Mumbai)
  • australia-southeast1 (Sydney)

Não é possível alterar a região de um aplicativo depois de defini-la.

Caso você já tenha criado um aplicativo do App Engine, execute o comando gcloud app describe ou abra o painel do App Engine no Console do GCP para ver a região. A região do seu aplicativo do App Engine será listada em http://[YOUR_PROJECT_ID].appspot.com.

Para este guia de início rápido, você precisa conhecer a linguagem de programação Go e instalar esse ambiente.

Fazer o download do app Hello World

Criamos um app Hello World para Go simples. Com ele, você tem uma ideia rápida da implantação de um app no Google Cloud Platform.

  1. Clone o repositório do app de amostra Hello World na máquina local.

    go get -u -d github.com/GoogleCloudPlatform/golang-samples/appengine_flexible
    

  2. Mude para o diretório que contém o código de amostra.

    cd $GOPATH/src/github.com/GoogleCloudPlatform/golang-samples/appengine_flexible/helloworld
    

Como executar o Hello World na máquina local

Para executar o aplicativo Hello World no seu computador:

  1. Inicie um servidor da Web local:

    go run *.go
    
  2. No navegador da Web, digite este endereço:

    http://localhost:8080

A mensagem Hello World do aplicativo de amostra é exibida na página. Na janela do terminal, pressione Ctrl+C para sair do servidor da Web.

Implantar e executar o Hello World no App Engine

Para implantar o aplicativo Hello World no ambiente flexível do App Engine:

  1. Implante o aplicativo Hello World executando o comando a seguir no diretório helloworld:

    gcloud app deploy

    Saiba mais sobre sinalizações opcionais.

    Sinalizações comuns do comando gcloud

    • Inclua a sinalização --version para especificar um código exclusivo da versão do seu app. Quando a sinalização não é incluída, o código é gerado automaticamente. Exemplo: --version [YOUR_VERSION_ID]
    • Inclua a sinalização --project para especificar um código do projeto do GCP como alternativa ao código definido como padrão na ferramenta gcloud. Exemplo: --project [YOUR_PROJECT_ID]

    Exemplo:

    gcloud app deploy --version pre-prod-5 --project my-sample-app

    Para aprender a implantar o app pela linha de comando, consulte Como testar e implantar o app. Para ver uma lista de todas as sinalizações de comando, consulte a referência de gcloud app deploy.

  2. Abra o navegador e veja o aplicativo em http://YOUR_PROJECT_ID.appspot.com.

    gcloud app browse
    em que YOUR_PROJECT_ID é o código do projeto do GCP.

Nesse momento, a página que exibe a mensagem Hello World é enviada por um servidor da Web em execução em uma instância do App Engine.

Parabéns! Você implantou seu primeiro aplicativo Go no ambiente flexível do App Engine.

Nas seções a seguir, veja informações sobre limpeza e links para as próximas etapas.

Limpeza

Exclua seu projeto do GCP para não ser cobrado pelos recursos usados nele.

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Próximas etapas

Agora que você já implantou o Hello World, comece a explorar o próximo aplicativo de amostra: o Bookshelf. Ele é um pouco mais completo, mas ainda é um aplicativo da Web básico para Go que usa vários recursos do Cloud Platform. Por exemplo, armazenamento de dados, autenticação, geração de registros, Pub/Sub e muito mais.

Iniciar o tutorial do aplicativo Bookshelf

Para mais informações sobre o ambiente flexível do App Engine, consulte Visão geral do App Engine.

Revisão do código do Hello World

Hello World é o app mais simples possível do App Engine. Nele, há apenas um serviço e uma versão, e todo o código é armazenado no diretório raiz. Nesta seção, cada arquivo do app é descrito em detalhes.

helloworld.go

O arquivo helloworld.go registra um gerenciador que detecta solicitações para / e responde com a mensagem "Hello world!".

package main

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

func main() {
	http.HandleFunc("/", handle)
	http.HandleFunc("/_ah/health", healthCheckHandler)
	log.Print("Listening on port 8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func handle(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}
	fmt.Fprint(w, "Hello world!")
}

func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "ok")
}

app.yaml

O arquivo app.yaml descreve a configuração de implantação do aplicativo:

# Copyright 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
#
#     https://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.

runtime: go
env: flex

# This sample incurs costs to run on the App Engine flexible environment.
# The settings below are to reduce costs during testing and are not appropriate
# for production use. For more information, see:
# https://cloud.google.com/appengine/docs/flexible/python/configuring-your-app-with-app-yaml
manual_scaling:
  instances: 1
resources:
  cpu: 1
  memory_gb: 0.5
  disk_size_gb: 10

O ambiente de execução usado pelo app é especificado no arquivo app.yaml, que define env: flex, determinando o uso do ambiente flexível pelo app.

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