Início rápido de ambientes de execução personalizados no ambiente flexível do App Engine

Os ambientes de execução personalizados permitem criar aplicativos executados em um ambiente definido por um Dockerfile. Usando um Dockerfile, você pode usar linguagens e pacotes que não fazem parte do Google Cloud Platform e usam os mesmos recursos e ferramentas usados no ambiente flexível do App Engine.

Neste início rápido, um servidor da Web nginx é lançado no App Engine usando um ambiente de execução personalizado.

Antes de começar

Antes de executar o aplicativo de exemplo neste início rápido, você precisa configurar seu ambiente e criar um novo projeto do GCP para o App Engine:

  1. Crie um novo projeto do GCP usando o Console do GCP:

    1. Abra o Console do GCP.

      Acessar a página "Projetos"

    2. Clique em Criar projeto e dê um nome ao seu novo projeto do GCP.

    3. Ative o faturamento no novo projeto do GCP criando uma nova conta de faturamento ou definindo uma atual:

      Acessar a página "Faturamento"

  2. Faça o download do SDK do Google Cloud e o instale. Depois, inicialize a ferramenta gcloud.

    Fazer download do SDK

  3. Execute o comando gcloud a seguir para criar um aplicativo do App Engine e especifique em qual região geográfica você quer que o aplicativo seja executado:

    gcloud app create
    

Locais do App Engine

O App Engine é regional, e isso significa que a infraestrutura que executa os aplicativos está localizada em uma região específica e é gerenciada pelo Google para ficar disponível de modo redundante em todas as zonas dessa região.

Atender aos requisitos de latência, disponibilidade ou durabilidade são os principais fatores para selecionar a região de execução dos seus aplicativos. Em geral, você escolhe a região mais próxima dos usuários do aplicativo. No entanto, pense também no local dos outros produtos e serviços do GCP utilizados pelo aplicativo. O uso de serviços em vários locais pode afetar a latência e o preço do seu aplicativo.

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

  • 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)
  • europe-west6 (Zurique)
  • asia-northeast1 (Tóquio)
  • asia-northeast2 (Osaka)
  • 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.

Se você já tiver criado um aplicativo do App Engine, poderá visualizar a região executando o comando gcloud app describe ou abrindo o Painel do App Engine no Console do GCP. A região do aplicativo do App Engine está listada em http://[YOUR_PROJECT_ID].appspot.com.

Download do app Hello World

  1. Escolha uma das seguintes opções para fazer o download do aplicativo de amostra Hello World do GitHub para a máquina local:

    • Clone o aplicativo de amostra Hello World do seguinte repositório:

      git clone https://github.com/GoogleCloudPlatform/appengine-custom-runtimes-samples
      
    • Faça o download da amostra (em inglês) como um arquivo .zip e, em seguida, extraia-o para um diretório local.

  2. Navegue até o diretório nginx em que o código de amostra está localizado, por exemplo:

    cd appengine-custom-runtimes-samples/nginx
    

Como executar o Hello World na máquina local

Você pode testar o aplicativo de amostra fazendo o download e a instalação do Docker, e executando o contêiner do Hello World em sua máquina local.

Não há etapas específicas do Google App Engine, então você pode testar o aplicativo de amostra usando as ferramentas e a abordagem que preferir.

Como implantar o Hello World no App Engine

Quando você estiver pronto para implantar o aplicativo de amostra no App Engine, execute estas etapas:

  1. No diretório em que Dockerfile e app.yaml estão localizados, execute o seguinte comando:

    gcloud app deploy
    

    Saiba mais sobre sinalizações opcionais.

  2. Para ver o aplicativo sendo executado em http://YOUR_PROJECT_ID.appspot.com, execute o seguinte comando para iniciar o navegador:

    gcloud app browse
    

Sinalizações comuns de comandos da gcloud

  • Inclua a sinalização --version para especificar um ID exclusivo da versão do seu app. Quando a sinalização não é incluída, o ID é gerado automaticamente. Exemplo: --version [YOUR_VERSION_ID]
  • Inclua a sinalização --project para especificar um ID do projeto do GCP como alternativa ao ID 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 uma lista de todas as sinalizações de comando, consulte a referência do gcloud app deploy.

Limpeza

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

  1. No Console do GCP, acesse a página Gerenciar recursos.

    Acessar a página Gerenciar recursos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Revisão de código

O Hello World é o aplicativo App Engine mais simples possível, já que cria um único contêiner que executa apenas um serviço e uma versão. Cada um dos arquivos do aplicativo é descrito em detalhes nesta seção.

app.yaml

Especifica a configuração do aplicativo. O arquivo app.yaml precisa residir no mesmo diretório que o arquivo Dockerfile.

runtime: custom
env: flex

A entrada de runtime: custom diz ao App Engine para procurar por um Dockerfile que definirá a imagem do seu ambiente de execução e env: flex especifica que você está implementando no ambiente flexível.

Para mais informações, consulte a referência do app.yaml.

Dockerfile

Define o conjunto de instruções usado para criar a imagem do Docker para o contêiner do aplicativo de amostra. O arquivo Dockerfile precisa estar no mesmo diretório que o arquivo app.yaml. Esse Dockerfile instala o servidor da Web nginx e copia algumas configurações básicas:

# The standard nginx container just runs nginx. The configuration file added
# below will be used by nginx.
FROM nginx

# Copy the nginx configuration file. This sets up the behavior of nginx, most
# importantly, it ensure nginx listens on port 8080. Google App Engine expects
# the runtime to respond to HTTP requests at port 8080.
COPY nginx.conf /etc/nginx/nginx.conf

# create log dir configured in nginx.conf
RUN mkdir -p /var/log/app_engine

# Create a simple file to handle heath checks. Health checking can be disabled
# in app.yaml, but is highly recommended. Google App Engine will send an HTTP
# request to /_ah/health and any 2xx or 404 response is considered healthy.
# Because 404 responses are considered healthy, this could actually be left
# out as nginx will return 404 if the file isn't found. However, it is better
# to be explicit.
RUN mkdir -p /usr/share/nginx/www/_ah && \
    echo "healthy" > /usr/share/nginx/www/_ah/health

# Finally, all static assets.
ADD www/ /usr/share/nginx/www/
RUN chmod -R a+r /usr/share/nginx/www

O comando FROM cria uma imagem base usando a imagem do Docker oficial para o servidor da Web nginx.

Usando esse Dockerfile, sua imagem do contêiner terá o nginx, e todo o conteúdo do diretório www/ estará disponível para seu aplicativo.

O aplicativo de amostra Hello World também inclui um arquivo nginx.conf (em inglês) que contém as informações básicas de configuração do nginx, bem como o arquivo index.html (em inglês), que serve como a página raiz do servidor da Web nginx.

Saiba mais

Saiba mais sobre Dockerfiles na referência do Dockerfile.

Para informações sobre como criar seu próprio ambiente de execução personalizado, consulte esta página (em inglês).