Como usar o Cloud SQL para MySQL com o Rails 5

Dê os primeiros passos no desenvolvimento de aplicativos Ruby on Rails executados no ambiente flexível do App Engine. Os aplicativos que você cria são executados na mesma infraestrutura que capacita todos os produtos do Google. Assim, você tem 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, mostramos como configurar o Cloud SQL para MySQL com um novo aplicativo do Rails. Também é possível usar este tutorial como referência para configurar aplicativos Rails atuais para usar o Cloud SQL para MySQL.

O tutorial requer o Ruby 2.3.4 ou posterior.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL Admin API.

Enable the API

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL Admin API.

Enable the API

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Como preparar o Cloud SQL para uma instância do MySQL

Para configurar o Cloud SQL para uma instância do MySQL para este tutorial, siga estas etapas:

Crie uma instância de segunda geração. Neste tutorial, o nome da instância é rails-cloudsql-instance.
Crie um banco de dados na instância. Neste tutorial, o nome do banco de dados de produção é cat_list_production.
Defina uma senha de usuário raiz para a instância.

Como configurar o ambiente local para Rails

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

Instale o Ruby na versão 2.3.4 ou posterior.
Instale a gem do Rails 5.
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, é possível criar e implantar um aplicativo Rails usando o Cloud SQL para MySQL. As seções a seguir orientam você na configuração, na conexão com o Cloud SQL para MySQL e na implantação de um aplicativo.

Criar um novo aplicativo para listar gatos

Execute o comando rails new para criar um novo aplicativo do Rails. Este aplicativo armazena uma lista de gatos no Cloud SQL para MySQL.
```
rails new cat_sample_app
```
Acesse o diretório que contém o aplicativo do Rails gerado.
```
cd cat_sample_app
```

Executar o aplicativo no local

Para executar o novo aplicativo do Rails no computador local:

Instale as dependências usando o Bundler:
```
bundle install
```
Inicie um servidor da Web local:
```
bundle exec bin/rails server
```
Em um navegador da Web, acesse http://localhost:3000/.

Uma mensagem Yay! Você está no Rails! do aplicativo é exibido 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.

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

Abra o arquivo config/routes.rb para ver o seguinte conteúdo gerado.

appengine/rails-cloudsql-mysql/config/routes.rb

Ver no GitHub

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

Adicione root 'cats#index' ao arquivo.

appengine/rails-cloudsql-mysql/config/routes.rb

Ver no GitHub

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

Salve e feche o arquivo.
Teste o aplicativo do Rails conforme indicado anteriormente.

Como usar o Cloud SQL para MySQL com o App Engine

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

Configurar o Cloud SQL para MySQL

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

Adicione as gems mysql2 e appengine ao arquivo Gemfile.
```
bundle add mysql2
bundle add appengine
```
O Gemfile do Rails contém as seguintes entradas gem adicionais:

appengine/rails-cloudsql-mysql/Gemfile

Ver no GitHub
```
# Added at 2017-08-07 11:54:06 -0700 by USER:
gem "mysql2", "~> 0.4.8"

# Added at 2017-08-07 11:54:12 -0700 by USER:
gem "appengine", "~> 0.4.1"
```
Observação: a gem appengine fornece uma tarefa Rake para executar migrações de banco de dados na produção.

Para configurar o aplicativo Rails para 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:

appengine/rails-cloudsql-mysql/config/boilerplate.database.yml

Ver no GitHub

# 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

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.
Modifique a configuração do banco de dados de produção database.yml para o seguinte:

appengine/rails-cloudsql-mysql/config/database.yml

Ver no GitHub
```
production:
  adapter: mysql2
  pool: 5
  timeout: 5000
  username: "[YOUR_MYSQL_USERNAME]"
  password: "[YOUR_MYSQL_PASSWORD]"
  database: "cat_list_production"
  socket:   "/cloudsql/[YOUR_INSTANCE_CONNECTION_NAME]"
```
Em que:
- [YOUR_MYSQL_USERNAME] representa seu nome de usuário do MySQL;
- [YOUR_MYSQL_PASSWORD] representa sua senha do MySQL;
- [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 ao implantar no ambiente flexível do App Engine.

Como implantar o aplicativo 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 do aplicativo. Se esse arquivo não estiver presente, a CLI gcloud 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:

appengine/rails-cloudsql-mysql/app.yaml

Ver no GitHub

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 production, defina a variável de ambiente SECRET_KEY_BASE com uma chave secreta para proteger os dados da sessão do usuário. Essa variável de ambiente é lida no arquivo config/secrets.yml no aplicativo do Rails.

Gere uma nova chave secreta.
```
bundle exec bin/rails secret
```
Copie a chave secreta gerada.
Abra o arquivo app.yaml criado anteriormente e adicione uma seção env_variables. O env_variables define variáveis de ambiente no ambiente flexível do App Engine. O arquivo app.yaml será semelhante ao exemplo a seguir com [SECRET_KEY] substituído pela chave secreta.

appengine/rails-cloudsql-mysql/app.yaml

Ver no GitHub
```
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.

Abra o arquivo app.yaml e adicione uma nova seção chamada beta_settings.
Defina um parâmetro aninhado cloud_sql_instances com o nome da conexão da instância como o valor.

Observação: é possível recuperar o nome da conexão da instância do Cloud SQL executando gcloud sql instances describe rails-cloudsql-instance.

O app.yaml precisa ser semelhante ao seguinte:

appengine/rails-cloudsql-mysql/app.yaml

Ver no GitHub
```
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.

Crie um aplicativo do App Engine.
```
gcloud app create
```
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, implante uma nova versão do aplicativo do Rails descrita no arquivo app.yaml sem redirecionar o tráfego da versão de veiculação padrão atual.

Pré-compile os ativos do Rails.

bundle exec bin/rails assets:precompile

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.

Liste os projetos disponíveis.
```
gcloud projects list
```
Na resposta, encontre o projeto que você quer usar para implantar o aplicativo e copie o número do projeto.
Adicione um novo membro à política do IAM do projeto para o papel roles/editor para executar migrações do banco de dados. Substitua [YOUR-PROJECT-ID] pelo ID do projeto do Google Cloud 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.

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

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

Você verá uma saída 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 ----------

Para verificar a migração do banco de dados, acesse:
```
[YOUR-VERSION]-dot-[YOUR-PROJECT-ID].appspot.com
```
Observação: para ver uma lista de versões, use gcloud app versions list. O último item da versão padrão do serviço é a implantação mais recente.

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 ler os registros do aplicativo, use o Explorador de registros localizado no Console do Google Cloud.

Saiba mais sobre como ler registros usando a CLI gcloud.

Fazer a limpeza dos recursos

Depois de concluir o tutorial, limpe os recursos que você criou para que eles parem de usar a cota e incorrer em cobranças. Nas seções a seguir, você aprenderá a 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:

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir uma versão do aplicativo do App Engine

Para excluir uma versão do app:

In the Google Cloud console, go to the Versions page for App Engine.
Go to Versions
Select the checkbox for the non-default app version that you want to delete.
Observação: A única maneira de excluir a versão padrão do seu aplicativo do App Engine é excluir o projeto. No entanto, é possível interromper a versão padrão no Console do Google Cloud. Isso encerra todas as instâncias associadas à versão. Você pode reiniciar essas instâncias posteriormente, se necessário.

No ambiente padrão do App Engine, apenas será possível interromper a versão padrão se o aplicativo tiver uma escala manual ou básica.
Para excluir a versão do app, clique em Excluir.

Excluir uma instância Cloud SQL

Para excluir uma instância do Cloud SQL:

In the Google Cloud console, go to the Instances page.
Go to Instances
Click the name of the SQL instance you that want to delete.
To delete the instance, click Delete, and then follow the instructions.

A seguir

Saiba como executar a amostra do Bookshelf em Ruby no ambiente flexível do App Engine.
Saiba como executar a amostra do Bookshelf em Ruby no Compute Engine.
Saiba como executar o aplicativo de amostra do Bookshelf em Ruby no Google Kubernetes Engine.

Como usar o Cloud SQL para MySQL com o Rails 5

Antes de começar

Como preparar o Cloud SQL para uma instância do MySQL

Como configurar o ambiente local para Rails

Criar um novo aplicativo para listar gatos

Executar o aplicativo no local

Gerar a estrutura de uma lista de gatos

Como usar o Cloud SQL para MySQL com o App Engine

Configurar o Cloud SQL para MySQL

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

Configurar a chave secreta do Rails no arquivo app.yaml

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

Criar um aplicativo de ambiente flexível do App Engine

Implantar uma nova versão

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

Migrar o banco de dados do Rails

Migrar o tráfego para a nova versão

Como ler registros do App Engine

Fazer a limpeza dos recursos

Excluir projeto

Excluir uma versão do aplicativo do App Engine

Excluir uma instância Cloud SQL

A seguir

Configurar a chave secreta do Rails no arquivo `app.yaml`

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

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