Como usar o Cloud SQL para PostgreSQL com o Rails 5

Dê os primeiros passos no desenvolvimento de aplicativos Ruby on Rails executados no ambiente flexível do App Engine. Como os aplicativos que você cria são executados na mesma infraestrutura que capacita todos os produtos do Google, tenha a certeza de que eles são escalonados para suprir todos os usuários, sejam eles poucos ou milhões.

Para acompanhar o tutorial, é preciso conhecer o desenvolvimento do Rails para a Web. No tutorial, você verá como configurar o Cloud SQL para PostgreSQL com um novo aplicativo do Rails. Também é possível usar este tutorial como referência para configurar aplicativos do Rails atuais para usar o Cloud SQL para MySQL.

O tutorial requer o Ruby 2.3.4 ou posterior.

Antes de começar

Marque as etapas conforme elas forem concluídas.

  1. check_box_outline_blankcheck_box Criar um projeto no Console do Google Cloud Platform.
    Caso ainda não tenha feito isso, crie um agora. Com os projetos, você gerencia todos os recursos do Google Cloud Platform para seu app, incluindo implantação, controle de acesso, faturamento e serviços.
    1. Abra o Console do GCP.
    2. No menu suspenso na parte superior, selecione Criar um projeto.
    3. Clique em Mostrar opções avançadas. Em Local do App Engine, selecione um local no Brasil.
    4. Dê um nome ao projeto.
    5. Anote o código do projeto, que pode ser diferente do nome do projeto. Esse ID é usado em comandos e configurações.
  2. check_box_outline_blankcheck_box Ativar o faturamento do projeto e se inscrever para uma avaliação gratuita.

    Caso ainda não tenha ativado o faturamento, faça isso agora e se inscreva para ter uma avaliação gratuita. A ativação do faturamento permite que recursos passíveis de cobrança, como execução de instâncias e armazenamento de dados, sejam usados no aplicativo. Você não será cobrado por nenhum serviço durante o período da avaliação gratuita.

  3. check_box_outline_blankcheck_box Instalar o SDK do Cloud.

    Instale e inicialize o SDK do Cloud agora, caso ainda não tenha feito isso. O SDK do Cloud contém ferramentas e bibliotecas que podem ser usadas para criar e gerenciar recursos no GCP.

  4. check_box_outline_blankcheck_box Ativar as APIs do projeto.

    Assim, você será direcionado para o Console do GCP, e as APIs usadas nesse tutorial serão ativadas. A API utilizada é a Cloud SQL Administration.

Como preparar uma instância do Cloud SQL para PostgreSQL

Configure o Cloud SQL para uma instância do PostgreSQL.

  1. Crie uma instância do PostgreSQL. Neste tutorial, o nome dela é rails-cloudsql-instance.

  2. Crie um banco de dados na instância. Neste tutorial, o nome do banco de dados de produção é cat_list_production.

  3. Defina a senha de usuário do Postgres para a instância.

Como configurar o ambiente local para Rails

Para configurar o ambiente local para este tutorial, siga estas etapas:

  1. Instale o Ruby na versão 2.3.4 ou posterior.

  2. Instale a gem do Rails 5.

  3. Instale a gem do Bundler.

Para mais informações sobre como instalar o Rails e as respectivas dependências, consulte o guia oficial Primeiros passos com o Rails (em inglês).

Depois de concluir os pré-requisitos, crie e implante um aplicativo do Rails com o Cloud SQL para PostgreSQL. As seções a seguir orientam você na configuração, na conexão com o Cloud SQL para PostgreSQL e na implantação de um aplicativo.

Criar um novo aplicativo para listar gatos

  1. Execute o comando rails new para criar um novo aplicativo do Rails. Este aplicativo armazena uma lista de gatos no Cloud SQL para PostgreSQL.

    rails new cat_sample_app
    
  2. Acesse o diretório que contém o aplicativo do Rails gerado.

    cd cat_sample_app
    

Executar o aplicativo localmente

Para executar o novo aplicativo do Rails no computador local, siga estas etapas:

  1. Instale dependências usando o Bundler.

    bundle install
    
  2. Inicie um servidor da Web local:

    bundle exec bin/rails server
    
  3. Em um navegador, acesse http://localhost:3000/.

Uma mensagem Yay! You're on Rails! do aplicativo é exibida na página.

Captura de tela do novo aplicativo do Rails em execução

Gerar a estrutura de uma lista de gatos

Gere a estrutura de um recurso chamado Cat que é usado para formar uma lista de gatos com o nome e a idade deles.

  1. Gere a estrutura.

    bundle exec rails generate scaffold Cat name:string age:integer
    

    O comando gera um modelo, um controlador e visualizações para o recurso Cat.

    invoke  active_record
    create    db/migrate/20170804210744_create_cats.rb
    create    app/models/cat.rb
    invoke    rspec
    create      spec/models/cat_spec.rb
    invoke  resource_route
    route    resources :cats
    invoke  scaffold_controller
    create    app/controllers/cats_controller.rb
    invoke    erb
    create      app/views/cats
    create      app/views/cats/index.html.erb
    create      app/views/cats/edit.html.erb
    create      app/views/cats/show.html.erb
    create      app/views/cats/new.html.erb
    create      app/views/cats/_form.html.erb
    invoke    jbuilder
    create      app/views/cats/index.json.jbuilder
    create      app/views/cats/show.json.jbuilder
    create      app/views/cats/_cat.json.jbuilder
    invoke  assets
    invoke    js
    create      app/assets/javascripts/cats.js
    invoke    scss
    create      app/assets/stylesheets/cats.scss
    invoke  scss
    create    app/assets/stylesheets/scaffolds.scss
    
  2. Abra o arquivo config/routes.rb para ver o seguinte conteúdo gerado.

    Rails.application.routes.draw do
      resources :cats
      get 'cats/index'
      # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
    
    end
  3. Adicione root 'cats#index' ao arquivo.

    Rails.application.routes.draw do
      resources :cats
      get 'cats/index'
    
      # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
      root 'cats#index'
    end
  4. Salve e feche o arquivo.

  5. Teste o aplicativo do Rails conforme indicado anteriormente.

Como usar o Cloud SQL para PostgreSQL com o App Engine

O Cloud SQL para PostgreSQL é um serviço de banco de dados totalmente gerenciado para configurar, manter, gerenciar e administrar seus bancos de dados PostgreSQL relacionais no Google Cloud Platform (GCP). É possível usar o Cloud SQL em um aplicativo do Rails como qualquer outro banco de dados relacional.

Configurar o Cloud SQL para PostgreSQL

Para começar a usar o Cloud SQL com seu aplicativo do Rails em produção, siga estas etapas:

  1. Adicione as gemas pg e appengine ao arquivo Gemfile.

    bundle add pg
    bundle add appengine
    

    O Gemfile do Rails contém as seguintes entradas gem adicionais:

    # Added at 2017-08-23 15:24:52 -0700 by franknatividad:
    gem "pg", "~> 0.21.0"
    
    # Added at 2017-08-07 11:54:12 -0700 by USER:
    gem "appengine", "~> 0.4.1"
  2. Para configurar o aplicativo Rails e se conectar ao Cloud SQL, abra o arquivo config/database.yml. As seguintes configurações do banco de dados padrão para o SQLite são exibidas:

    # SQLite version 3.x
    #   gem install sqlite3
    #
    #   Ensure the SQLite 3 gem is defined in your Gemfile
    #   gem 'sqlite3'
    #
    default: &default
      adapter: sqlite3
      pool: 5
      timeout: 5000
    
    development:
      <<: *default
      database: db/development.sqlite3
    
    # Warning: The database defined as "test" will be erased and
    # re-generated from your development database when you run "rake".
    # Do not set this db to the same as development or production.
    test:
      <<: *default
      database: db/test.sqlite3
    
    production:
      <<: *default
      database: db/production.sqlite3
  3. Configure o nome da conexão da instância do Cloud SQL para o ambiente de produção do App Engine.

    1. Recupere o nome da conexão da instância.

      gcloud sql instances describe rails-cloudsql-instance
      
    2. Copie o valor ao lado de connectionName.

  4. Modifique a configuração do banco de dados de produção database.yml da seguinte maneira:

    production:
      adapter: postgresql
      encoding: unicode
      pool: 5
      timeout: 5000
      username: "[YOUR_POSTGRES_USERNAME]"
      password: "[YOUR_POSTGRES_PASSWORD]"
      database: "cat_list_production"
      host:   "/cloudsql/[YOUR_INSTANCE_CONNECTION_NAME]"

    Em que:

    • [YOUR_POSTGRES_USERNAME] representa seu nome de usuário do PostgreSQL;
    • [YOUR_POSTGRES_PASSWORD] representa sua senha do PostgreSQL;
    • [YOUR_INSTANCE_CONNECTION_NAME] representa o nome da conexão da instância que você copiou na etapa anterior.

Agora, o aplicativo do Rails está configurado para usar o Cloud SQL quando fizer implantações no ambiente flexível do App Engine.

Como implantar o app no ambiente flexível do App Engine

O ambiente flexível do App Engine usa um arquivo denominado app.yaml para descrever a configuração de implantação de um aplicativo. Se o arquivo estiver faltando, o SDK do Cloud tentará deduzir a configuração da implantação. No entanto, é preciso definir o arquivo para fornecer as configurações necessárias do Cloud SQL e da chave secreta do Rails.

Para configurar o aplicativo de amostra para implantação no App Engine, crie um novo arquivo chamado app.yaml na raiz do diretório do aplicativo do Rails e adicione o seguinte:

entrypoint: bundle exec rackup --port $PORT
env: flex
runtime: ruby

Configurar a chave secreta do Rails no arquivo app.yaml

Quando um aplicativo do Rails é implantado no ambiente de production, defina a variável de ambiente SECRET_KEY_BASE com uma chave secreta para proteger os dados da sessão do usuário. Ela é lida no arquivo config/secrets.yml do aplicativo.

  1. Gere uma nova chave secreta.

    bundle exec bin/rails secret
    
  2. Copie a chave secreta gerada.

  3. Abra o arquivo app.yaml que você criou anteriormente e inclua uma seção env_variables. O env_variables define variáveis para o ambiente flexível do App Engine. O arquivo app.yaml será semelhante ao exemplo a seguir, com [SECRET_KEY] substituído por sua chave secreta.

    entrypoint: bundle exec rackup --port $PORT
    env: flex
    runtime: ruby
    
    env_variables:
      SECRET_KEY_BASE: [SECRET_KEY]

Configurar a instância do Cloud SQL no arquivo app.yaml

Em seguida, configure o ambiente flexível do App Engine para usar uma instância especificada do Cloud SQL, fornecendo o nome da conexão de instância do Cloud SQL no arquivo de configuração app.yaml.

  1. Abra o arquivo app.yaml e adicione uma nova seção chamada beta_settings.

  2. Defina um parâmetro aninhado cloud_sql_instances com o nome da conexão da instância como o valor.

    O app.yaml será semelhante a:

    entrypoint: bundle exec rackup --port $PORT
    env: flex
    runtime: ruby
    
    env_variables:
      SECRET_KEY_BASE: [SECRET_KEY]
    
    beta_settings:
      cloud_sql_instances: [YOUR_INSTANCE_CONNECTION_NAME]

Criar um aplicativo de ambiente flexível do App Engine

Se esta é a primeira vez que você está implantando um aplicativo, é preciso criar um aplicativo de ambiente flexível do App Engine e selecionar a região em que você quer executar o aplicativo do Rails.

  1. Crie um aplicativo do App Engine.

    gcloud app create
    
  2. Selecione uma região compatível com o ambiente flexível do App Engine para aplicativos em Ruby. Leia mais sobre Regiões e zonas.

Implantar uma nova versão

Em seguida, implemente uma nova versão do aplicativo do Rails descrita no arquivo app.yaml sem redirecionar o tráfego da versão de serviço padrão atual.

  1. Pré-compile os ativos do Rails.

    bundle exec bin/rails assets:precompile
    
  2. Após a conclusão da compilação dos ativos, implante uma nova versão do aplicativo.

    gcloud app deploy --no-promote
    

    A conclusão da implantação leva alguns minutos. Espere até surgir uma mensagem de sucesso. É possível visualizar as versões implantadas na lista de versões do App Engine.

Depois de implantar a nova versão, se você tentar acessá-la, a seguinte mensagem de erro será exibida. Isso acontece porque você não migrou o banco de dados.

Captura de tela da mensagem de erro do novo aplicativo do Rails

Conceder a permissão necessária para a gem appengine

Em seguida, conceda acesso à conta de serviço cloudbuild para executar migrações do banco de dados de produção com a gem appengine.

  1. Liste os projetos disponíveis.

    gcloud projects list
    
  2. Na resposta, encontre o projeto que você quer usar para implantar o aplicativo e copie o número do projeto.

  3. Adicione um membro novo à política do IAM do projeto para o papel roles/editor executar migrações de banco de dados. Substitua [YOUR-PROJECT-ID] pelo código do projeto do GCP e substitua [PROJECT_NUMBER] pelo número do projeto que você copiou na etapa anterior.

    gcloud projects add-iam-policy-binding [YOUR-PROJECT-ID] \
      --member=serviceAccount:[PROJECT_NUMBER]@cloudbuild.gserviceaccount.com \
      --role=roles/editor
    

Migrar o banco de dados do Rails

Com essas migrações, é possível atualizar o esquema do banco de dados sem usar diretamente a sintaxe do SQL. Em seguida, você migra seu banco de dados cat_list_production.

A gem appengine fornece a tarefa Rake appengine:exec para executar um comando na versão mais recente do aplicativo implantada no ambiente de produção flexível do App Engine.

  1. Migre o banco de dados cat_list_production do Cloud SQL para PostgreSQL em produção.

    bundle exec rake appengine:exec -- bundle exec rake db:migrate
    

    Você verá um resultado como:

    ---------- EXECUTE COMMAND ----------
    bundle exec rake db:migrate
    Debuggee gcp:787021104993:8dae9032f8b02004 successfully registered
    == 20170804210744 CreateCats: migrating =======================================
    -- create_table(:cats)
       -> 0.0219s
    == 20170804210744 CreateCats: migrated (0.0220s) ==============================
    
    ---------- CLEANUP ----------
    
  2. Para verificar a migração do banco de dados, acesse:

    [YOUR-VERSION]-dot-[YOUR-PROJECT-ID].appspot.com
    

Ao concluir a implantação, você verá o seguinte:

Captura de tela do novo aplicativo do Rails em execução

Migrar o tráfego para a nova versão

Por fim, direcione o tráfego para a versão recém-implantada usando o comando a seguir:

gcloud app services set-traffic default --splits [YOUR-VERSION]=1

A nova versão do aplicativo agora está acessível em:

https://[YOUR-PROJECT-ID].appspot.com

Como ler registros do App Engine

Agora que você já implantou o aplicativo do Rails, será possível ler os registros. Para fazer isso, utilize o Visualizador de registros localizado no Console do Google Cloud Platform.

Saiba mais sobre como ler registros usando o SDK do Cloud.

Fazer a limpeza dos recursos

Depois de concluir o tutorial "Como usar o Cloud SQL para PostgreSQL com o Rails 5", limpe os recursos criados no GCP para que eles não ocupem cotas e sejam cobrados no futuro. Nas seções a seguir, veja como excluir e desativar esses recursos.

Excluir projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

  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.

Excluir uma versão do aplicativo do App Engine

Para excluir uma versão do aplicativo:

  1. No Console do GCP, acesse a página "Versões do App Engine".

    Acessar a página Versões

  2. Clique na caixa de seleção ao lado da versão do aplicativo não padrão que você quer excluir.
  3. Clique no botão Excluir na parte superior da página para excluir a versão do aplicativo.

Excluir uma instância do Cloud SQL

Para excluir uma instância do Cloud SQL:

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

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

  2. Clique no nome a instância de SQL que você quer excluir.
  3. Clique no botão Excluir na parte superior da página para excluir a instância.

A seguir

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

Enviar comentários sobre…