Como executar o aplicativo Bookshelf em Ruby no Compute Engine

Neste tutorial, você aprenderá a executar o aplicativo de amostra Bookshelf em Ruby no Compute Engine. Acompanhe as instruções para implantar um aplicativo atual da Web em Ruby no Compute Engine. É recomendável usar a documentação do aplicativo Bookshelf como parte do tutorial do ambiente padrão do App Engine.

Objetivos

  • Implantar o app de amostra Bookshelf em uma única instância do Compute Engine.
  • Escalonar o app horizontalmente usando um grupo de instâncias gerenciadas.
  • Veicular o tráfego usando o balanceamento de carga HTTP.
  • Responder a mudanças de tráfego usando o escalonamento automático.

Custos

Neste tutorial, os seguintes componentes faturáveis do Google Cloud Platform são usados:

Use a calculadora de preços para gerar uma estimativa de custo com base no uso do projeto. Novos usuários do GCP são qualificados para uma avaliação gratuita.

Ao concluir este tutorial, exclua os recursos criados para evitar a continuidade no faturamento. Veja mais detalhes em Limpeza.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. {% dynamic if "no_credentials" in setvar.task_params %}{% dynamic setvar credential_type %}NO_AUTH{% dynamic endsetvar %}{% dynamic if not setvar.redirect_url %}{% dynamic setvar redirect_url %}https://console.cloud.google.com{% dynamic endsetvar %}{% dynamic endif %}{% dynamic endif %}{% dynamic if setvar.in_henhouse_no_auth_whitelist %}{% dynamic if not setvar.credential_type %}{% dynamic setvar credential_type %}NO_AUTH{% dynamic endsetvar %}{% dynamic endif %}{% dynamic elif setvar.in_henhouse_service_account_whitelist %}{% dynamic if not setvar.credential_type %}{% dynamic setvar credential_type %}SERVICE_ACCOUNT{% dynamic endsetvar %}{% dynamic endif %}{% dynamic endif %}{% dynamic if not setvar.service_account_roles and setvar.credential_type == "SERVICE_ACCOUNT" %}{% dynamic setvar service_account_roles %}{% dynamic endsetvar %}{% dynamic endif %}{% dynamic setvar console %}{% dynamic if "no_steps" not in setvar.task_params %}
  5. {% dynamic endif %}{% dynamic if setvar.api_list %}{% dynamic if setvar.in_henhouse_no_auth_whitelist or setvar.in_henhouse_service_account_whitelist %} Configure um projeto do Console do GCP.

    Configurar um projeto

    Clique para:

    • criar ou selecionar um projeto;
    • ativar {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}obrigatória{% dynamic endif %}{% dynamic if "," in setvar.api_list %} APIs{% dynamic elif "API" in setvar.api_names %}{% dynamic else %} API{% dynamic endif %} para o projeto;
    • {% dynamic if setvar.credential_type == 'SERVICE_ACCOUNT' %}
    • criar uma conta de serviço;
    • fazer o download de uma chave privada como JSON.
    • {% dynamic endif %}

    É possível ver e gerenciar esses recursos a qualquer momento no Console do GCP.

    {% dynamic else %}{% dynamic if "no_text" not in setvar.task_params %} Ativar {% dynamic if setvar.api_names %}{% dynamic print setvar.api_names %}{% dynamic else %}obrigatória{% dynamic endif %}{% dynamic if "," in setvar.api_list %} APIs{% dynamic elif "API" in setvar.api_names %}{% dynamic else %} API{% dynamic endif %}. {% dynamic endif %}

    Ativar {% dynamic if "," in setvar.api_list %} as APIs{% dynamic else %} a API{% dynamic endif %}

    {% dynamic endif %}{% dynamic endif %}{% dynamic if "no_steps" not in setvar.task_params %}
  6. {% dynamic endif %}{% dynamic endsetvar %}{% dynamic print setvar.console %}
  7. Instale e inicialize o SDK do Cloud.
  8. Instale o Ruby 2.3 ou versão posterior e o Ruby on Rails. Também é necessário ter o Ruby Gems, incluso no Ruby.

Como inicializar o Cloud Datastore

O aplicativo de amostra Bookshelf usa o Cloud Datastore para armazenar os livros. Para inicializá-lo no seu projeto pela primeira vez, faça o seguinte:

  1. No Console do Google Cloud Platform, abra o Cloud Datastore.

    Abrir o Cloud Datastore

  2. Selecione uma região para o armazenamento de dados e clique em Continuar.

    Quando acessar a página Criar uma entidade, feche a janela. O aplicativo Bookshelf estará pronto para criar entidades no Cloud Datastore.

Como criar um intervalo do Cloud Storage

Veja nas instruções a seguir como criar um intervalo do Cloud Storage. Intervalos são os contêineres básicos que armazenam dados no Cloud Storage.

  1. Em uma janela de terminal, digite o seguinte comando:

    gsutil mb gs://[YOUR-BUCKET-NAME]

    [YOUR-BUCKET-NAME] representa o nome do intervalo do Cloud Storage.

  2. Para visualizar imagens que foram carregadas no aplicativo Bookshelf, defina a lista de controle de acesso (ACL, na sigla em inglês) padrão do intervalo como public-read.

    gsutil defacl set public-read gs://[YOUR-BUCKET-NAME]

Como clonar o aplicativo de amostra

O aplicativo de amostra está disponível no GitHub em GoogleCloudPlatform/getting-started-ruby.

  1. Clone o repositório.

    git clone https://github.com/GoogleCloudPlatform/getting-started-ruby.git
    
  2. Acesse o diretório da amostra.

    cd getting-started-ruby/7-compute-engine
    

Como configurar o app

  1. Instale as dependências.

    bundle install
    
  2. Crie arquivos de configuração copiando os exemplos fornecidos. Os caminhos do arquivo de configuração estão em .gitignore e não estão comprometidos com o controle de versão.

    cp config/database.example.yml config/database.yml
    cp config/settings.example.yml config/settings.yml
    
  3. Abra config/settings.yml para editá-lo e substitua os valores a seguir:

    • @@PROJECT_ID@@ pelo código do projeto;
    • @@BUCKET_NAME@@ pelo nome do intervalo de armazenamento que você criou na etapa anterior;
    • @@CLIENT_ID@@ pelo código de cliente do OAuth;
    • @@CLIENT_SECRET@@ pela chave secreta do cliente do OAuth.
  4. Salve e feche settings.yml.

  5. Abra config/database.yml para editá-lo e substitua @@PROJECT_ID@@ pelo código do projeto.

  6. Salve e feche database.yml.

Como executar o app no computador local

  1. Inicie um servidor da Web local.

    rails server
    
  2. No navegador da Web, digite http://localhost:3000.

    Para interromper o servidor da Web local, pressione Control+C.

Executar o trabalho no computador local

O trabalho usa a sequência de enfileiramento Resque. O Resque usa o Redis como base. Por isso, para se conectar ao worker, é necessário ter um servidor Redis em execução local na porta 6379. Consulte o Guia de início rápido do Redis para começar.

Após a execução do Redis, digite o comando a seguir em uma nova janela de comando:

TERM_CHILD=1 QUEUE=* rake environment resque:work

Agora, adicione alguns livros ao aplicativo Bookshelf. Se a instância do aplicativo e do worker estiverem em execução localmente, será possível observar o worker atualizando as informações do livro em segundo plano.

A interface do Resque está configurada para ficar disponível no endereço a seguir, que pode ser usado para verificar o status do seu worker:

http://localhost:3000/resque

Como implantar em uma única instância

Single-instance deployment

Nesta seção, mostramos como executar uma única instância do aplicativo no Compute Engine.

Enviar o código para um repositório

Use o Cloud Source Repositories para criar um repositório Git no projeto e faça o upload do código do aplicativo para esse repositório. Assim, as instâncias podem receber do repositório a versão mais recente do código do app durante a inicialização. Usar um repositório Git é conveniente porque a atualização do seu aplicativo não exige a configuração de novas imagens ou instâncias. Basta reiniciar uma instância atual ou criar uma.

Se for a primeira vez que você usa o Git, utilize git config --global para configurar sua identidade (em inglês).

  1. No Console do GCP, crie um repositório:

    Criar repositório

  2. Envie o código do aplicativo para o repositório do projeto.

    git commit -am "Updating configuration"
    git config credential.helper gcloud.sh
    git remote add cloud https://source.developers.google.com/p/[YOUR_PROJECT_ID]/r/[YOUR_REPO]
    git push cloud master
    

    em que [YOUR_PROJECT_ID] é o ID do projeto e [YOUR_REPO] é o nome do repositório.

Usar um script para inicializar uma instância

Agora que o código pode ser acessado pelas instâncias do Compute Engine, é necessário instruir sua instância para que ela faça o download e execute o código. Isso pode ser feito por meio de um script de inicialização que é executado sempre que a instância for iniciada ou reiniciada.

Veja a seguir os scripts de inicialização incluídos no aplicativo de amostra Bookshelf:

set -e

# Talk to the metadata server to get the project id
PROJECTID=$(curl -s "http://metadata.google.internal/computeMetadata/v1/project/project-id" -H "Metadata-Flavor: Google")
REPO_NAME="[YOUR_REPO_NAME]"

# Get the source code
export HOME=/root
git config --global credential.helper gcloud.sh
# Change branch from master if not using master
git clone https://source.developers.google.com/p/$PROJECTID/r/$REPO_NAME /opt/app -b master

pushd /opt/app/7-compute-engine

pushd config

cp database.example.yml database.yml
chmod go-rwx database.yml
cp settings.example.yml settings.yml
chmod go-rwx settings.yml

# Add your GCP project ID here
sed -i -e 's/@@PROJECT_ID@@/[YOUR_PROJECT_ID]/' settings.yml
sed -i -e 's/@@PROJECT_ID@@/[YOUR_PROJECT_ID]/' database.yml

# Add your cloud storage config here
sed -i -e 's/@@BUCKET_NAME@@/[YOUR_BUCKET_NAME]/' settings.yml

# Add your OAuth config here
sed -i -e 's/@@CLIENT_ID@@/[YOUR_CLIENT_ID]/' settings.yml
sed -i -e 's/@@CLIENT_SECRET@@/[YOUR_CLIENT_SECRET]/' settings.yml
popd # config

./gce/configure.sh

popd # /opt/app
set -e

curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
cat >/etc/google-fluentd/config.d/railsapp.conf << EOF
<source>
  type tail
  format none
  path /opt/app/7-compute-engine/log/*.log
  pos_file /var/tmp/fluentd.railsapp.pos
  read_from_head true
  tag railsapp
</source>
EOF
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -y git ruby ruby-dev build-essential libxml2-dev zlib1g-dev nginx libmysqlclient-dev libsqlite3-dev redis-server

gem install bundler --no-ri --no-rdoc

useradd -m railsapp
chown -R railsapp:railsapp /opt/app

mkdir /opt/gem
chown -R railsapp:railsapp /opt/gem

sudo -u railsapp -H bundle install --path /opt/gem
sudo -u railsapp -H bundle exec rake assets:precompile

systemctl enable redis-server.service
systemctl start redis-server.service

cat gce/default-nginx > /etc/nginx/sites-available/default
systemctl restart nginx.service

cat gce/railsapp.service > /lib/systemd/system/railsapp.service
systemctl enable railsapp.service
systemctl start railsapp.service

cat gce/resqworker.service > /lib/systemd/system/resqworker.service
systemctl enable resqworker.service
systemctl start resqworker.service

Estas tarefas são executadas pelo script de inicialização:

  1. Clonagem do código-fonte do aplicativo Cloud Source Repositories e definição de arquivos de configuração com suas chaves secretas.

  2. Instalação do agente do Logging e configuração dele para monitorar os registros do aplicativo. Isso significa que os registros configurados no tutorial anterior são enviados para a seção de geração de registro do Console do GCP como se você estivesse usando o App Engine.

  3. Instalação e configuração do Ruby, Rails e NGINX.

Personalizar o script de inicialização

No aplicativo de amostra, há um modelo do script de inicialização que pode ser modificado para conter suas chaves secretas. Não registre as chaves secretas no controle da origem.

  1. Copie o modelo de script de inicialização em uma chave secreta que será modificada sem fazer o registro:

    cp gce/startup-script.sh gce/my-startup.sh
    
  2. Edite o arquivo my-startup.sh.

    Adicione suas chaves secretas ao seu banco de dados e ao Cloud Storage. Elas são as mesmas que você adicionou anteriormente ao database.yml e settings.yml. Substitua os marcadores [YOUR_* pelos valores adequados.

    Veja um exemplo:

    # Add your GCP project ID here
    sed -i -e 's/PROJECT_ID/your-project-id/' settings.yml
    sed -i -e 's/PROJECT_ID/your-project-id/' database.yml
    
    # Add your Cloud Storage config here
    sed -i -e 's/BUCKET_NAME/your-bucket-name/' settings.yml
    
    # Add your OAuth config here
    sed -i -e 's/CLIENT_ID/1234/' settings.yml
    sed -i -e 's/CLIENT_SECRET/1234/' settings.yml
    

Criar e configurar uma instância do Compute Engine

  1. Crie uma instância do Compute Engine.

    O comando a seguir cria uma instância, permite que ela acesse os serviços do GCP e executa o script de inicialização. O nome da instância é my-app-instance.

    Linux/macOS

    gcloud compute instances create my-app-instance \
        --machine-type=g1-small \
        --scopes logging-write,storage-rw,datastore,https://www.googleapis.com/auth/projecthosting \
        --metadata-from-file startup-script=gce/my-startup.sh \
        --zone us-central1-f \
        --tags http-server \
        --image-family ubuntu-1604-lts \
        --image-project ubuntu-os-cloud
    

    Windows

    gcloud compute instances create my-app-instance ^
        --machine-type=g1-small ^
        --scopes logging-write,storage-rw,datastore,https://www.googleapis.com/auth/projecthosting ^
        --metadata-from-file startup-script=gce/my-startup.sh ^
        --zone us-central1-f ^
        --tags http-server ^
        --image-family ubuntu-1604-lts ^
        --image-project ubuntu-os-cloud
    

  2. Verifique o andamento da criação da instância:

    gcloud compute instances get-serial-port-output my-app-instance --zone us-central1-f
    

    Se o script de inicialização estiver concluído, você verá Finished running startup script quase no final da resposta ao comando.

  3. Crie uma regra de firewall para permitir o tráfego para a instância.

    Linux/macOS

    gcloud compute firewall-rules create default-allow-http-80 \
        --allow tcp:80 \
        --source-ranges 0.0.0.0/0 \
        --target-tags http-server \
        --description "Allow port 80 access to http-server"
    

    Windows

    gcloud compute firewall-rules create default-allow-http-80 ^
        --allow tcp:80 ^
        --source-ranges 0.0.0.0/0 ^
        --target-tags http-server ^
        --description "Allow port 80 access to http-server"
    

  4. Receba o endereço IP externo da instância.

    gcloud compute instances list
    
  5. Para ver o aplicativo em execução, acesse http://[YOUR_INSTANCE_IP],

    em que [YOUR_INSTANCE_IP] é o endereço IP externo da instância.

Gerenciar e monitorar uma instância

Use o Console do GCP para monitorar e gerenciar a instância.

  • Para visualizar a instância em execução e conectar-se a ela usando o ssh, no Console do GCP, acesse a página de Instâncias de VMs.

    Acessar a página de Instâncias de VMs

  • Para visualizar todos os registros gerados pelos recursos do Compute Engine, no Console do GCP, acesse a página Registros.

    Acessar a página "Registros"

    O Logging é configurado automaticamente para reunir registros de vários serviços comuns, incluindo o syslog.

Escalonamento horizontal com várias instâncias

Implantação de várias instâncias com instâncias gerenciadas

O Compute Engine pode ser escalonado de maneira horizontal. Com um grupo de instâncias gerenciadas e o autoescalador, o Compute Engine é capaz de criar automaticamente novas instâncias do aplicativo quando necessário e encerrá-las quando a demanda estiver baixa. Configure um balanceador de carga HTTP para distribuir o tráfego para as instâncias em um grupo de instâncias gerenciadas.

Script de implantação

O aplicativo de amostra inclui um script que automatiza as etapas de implantação a seguir. Com o script deploy.sh, os recursos são implantados em um aplicativo completo que conta com escalonamento automático e balanceamento de carga, conforme descrito em Escalonamento horizontal com várias instâncias.

É possível realizar cada uma das etapas a seguir manualmente ou executar gce/deploy.sh no diretório gce.

Criar um grupo de instâncias gerenciadas

Um grupo de instâncias gerenciadas é composto de instâncias homogêneas que têm o mesmo modelo como base. Esse modelo define a configuração da instância, incluindo imagem de origem, tamanho do disco, escopos e metadados, além de scripts de inicialização.

  1. Crie um modelo.

    gcloud compute instance-templates create my-app-tmpl \
        --machine-type=g1-small \
        --scopes logging-write,storage-rw,datastore,https://www.googleapis.com/auth/projecthosting \
        --metadata-from-file startup-script=gce/my-startup.sh \
        --image-family ubuntu-1604-lts \
        --image-project ubuntu-os-cloud \
        --tags http-server
    
  2. Crie um grupo de instâncias.

    gcloud compute instance-groups managed create my-app-group \
        --base-instance-name my-app \
        --size 2 \
        --template my-app-tmpl \
        --zone us-central1-f
    

    O parâmetro --size especifica o número de instâncias no grupo. Quando todas as instâncias concluírem a execução dos scripts de inicialização, será possível acessar as instâncias individualmente usando os endereços IP externos delas e a porta 8080. Para consultar os endereços IP externos das instâncias, digite gcloud compute instances list. Os nomes das instâncias gerenciadas começam com o mesmo prefixo, my-app, especificado no parâmetro --base-instance-name.

Criar um balanceador de carga

Uma instância individual é ideal para testes ou depuração. Entretanto, para veicular o tráfego da Web, é recomendável usar um balanceador de carga porque ele direciona o tráfego automaticamente para as instâncias disponíveis. Para criar um balanceador, siga as etapas abaixo.

  1. Crie uma verificação de integridade.

    O balanceador de carga usa essa verificação para determinar quais instâncias podem veicular o tráfego.

    gcloud compute http-health-checks create bookshelf-health-check \
        --request-path / \
        --port 8080
    
  2. Crie uma porta nomeada.

    O balanceador de carga HTTP verifica o serviço http a fim de descobrir para qual porta direcionar o tráfego. No grupo de instâncias atual, nomeie a porta 8080 como http.

    gcloud compute instance-groups managed set-named-ports my-app-group \
        --named-ports http:8080 \
        --zone us-central1-f
    
  3. Crie um serviço de back-end.

    Esse serviço é o destino do tráfego com carga balanceada. Ele define para qual grupo de instâncias o tráfego é direcionado e qual verificação de integridade precisa ser usada.

    gcloud compute backend-services create my-app-service \
        --http-health-check bookshelf-health-check
    
  4. Adicione o serviço de back-end.

    gcloud compute backend-services add-backend my-app-service \
        --group my-app-group \
        --zone us-central1-f
    
  5. Crie um mapa de URL e um proxy.

    O mapa define quais URLs são direcionadas para quais serviços de back-end. Nesta amostra, todo o tráfego é veiculado por um serviço de back-end. Se você quiser fazer o balanceamento de carga entre diversas regiões ou grupos, crie vários serviços de back-end. Um proxy recebe o tráfego e o encaminha para os serviços de back-end usando os mapas de URL.

    1. Crie o mapa de URL.

      gcloud compute url-maps create my-app-service-map \
          --default-service my-app-service
      
    2. Crie o proxy.

      gcloud compute target-http-proxies create my-app-service-proxy \
          --url-map my-app-service-map
      
  6. Crie uma regra de encaminhamento global. Ela vincula um endereço IP público e uma porta a um proxy.

    gcloud compute forwarding-rules create my-app-service-http-rule \
        --global \
        --target-http-proxy my-app-service-proxy \
        --port-range 80
    

Configurar o autoescalador

Com o balanceador de carga, você garante que o tráfego seja distribuído entre todas as instâncias íntegras. Mas o que acontece quando há muito tráfego para as instâncias processarem? Uma saída seria adicionar manualmente mais instâncias. No entanto, a melhor solução é configurar um autoescalador do Compute Engine para criar e excluir automaticamente as instâncias de acordo com a demanda de tráfego.

  1. Crie um autoescalador.

    gcloud compute instance-groups managed set-autoscaling my-app-group \
        --max-num-replicas 10 \
        --target-load-balancing-utilization 0.5 \
        --zone us-central1-f
    

    O comando anterior cria um autoescalador no grupo de instâncias gerenciadas. Ele realiza o escalonamento automático de até 10 instâncias. Quando o balanceador de carga ultrapassa 50% de utilização, novas instâncias são adicionadas e, quando fica abaixo de 50%, elas são removidas.

  2. Verifique o progresso até que pelo menos uma das instâncias apresente o status HEALTHY.

    gcloud compute backend-services get-health frontend-web-service --global
    

Visualizar o aplicativo

  1. Consulte o endereço IP de encaminhamento para o balanceador de carga.

    gcloud compute forwarding-rules list --global
    

    O endereço IP das regras de encaminhamento está na coluna IP_ADDRESS.

  2. Em um navegador, digite o endereço IP da lista.

    Agora, o aplicativo com balanceamento de carga e escalonamento automático está em execução no Compute Engine.

Gerenciar e monitorar a implantação

Use o Console do GCP para monitorar o balanceamento de carga, o escalonamento automático e o grupo de instâncias gerenciadas.

Como fazer a limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

Executar o script de desmontagem

Se tiver usado deploy.sh, execute o script teardown.sh para remover todos os recursos criados pelo deploy.sh. Isso faz com que o projeto retorne ao estado anterior à execução do script deploy.sh e ajuda a evitar mais cobranças. Para remover a instância única e o intervalo de armazenamento criados no início do tutorial, siga as instruções da próxima seção.

Excluir recursos manualmente

Se você tiver seguido as etapas deste tutorial manualmente, é possível excluir os recursos da nuvem de mesma maneira.

Excluir o balanceador de carga

  1. No Console do GCP, acesse a página Balanceamento de carga.

    Acessar a página "Balanceamento de carga"

  2. Marque a caixa de seleção ao lado do balanceador de carga que você quer excluir e clique em Excluir delete.

  3. Na caixa de diálogo Excluir balanceador de carga, selecione os recursos de verificação de integridade e o serviço de back-end associados. Em seguida, clique em Excluir delete. O balanceador de carga e os recursos associados serão excluídos.

Excluir o grupo de instâncias gerenciadas do Compute Engine

Para excluir um grupo de instâncias do Compute Engine:

  1. No Console do GCP, acesse a página "Grupos de instâncias".

    Acessar a página "Grupos de instâncias"

  2. Clique na caixa de seleção ao lado do do grupo de instâncias que deseja excluir..
  3. Clique no botão Excluir na parte superior da página para excluir o grupo de instâncias.

Excluir uma única instância do Compute Engine

Para excluir uma instância do Compute Engine:

  1. No Console do GCP, acesse a página "Instâncias de VM".

    Acessar a página "Instâncias de VMs"

  2. Clique na caixa de seleção ao lado da da instância que deseja excluir.
  3. Clique no botão Excluir na parte superior da página para excluir a instância.

Excluir o intervalo do Cloud Storage

Para excluir um intervalo do Google Cloud Storage:

  1. No Console do GCP, acesse o navegador do Cloud Storage.

    Acessar o navegador do Cloud Storage

  2. Marque a caixa de seleção ao lado do intervalo que você quer excluir.
  3. Para excluir o intervalo, clique no botão Excluir no topo da página.

A seguir

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

Enviar comentários sobre…