Como executar o aplicativo Bookshelf em Ruby no Google Kubernetes Engine

Neste tutorial, você aprenderá a executar o aplicativo de amostra Bookshelf em Ruby no Google Kubernetes Engine (GKE). Siga este tutorial implantar um aplicativo atual da Web em Ruby no GKE e executá-lo em contêineres. É recomendável usar a documentação do aplicativo Bookshelf como parte do tutorial do ambiente padrão do App Engine.

Objetivos

  • Criar um cluster do GKE.
  • Colocar um aplicativo em Ruby em um contêiner.
  • Criar um front-end replicado para o aplicativo Bookshelf.
  • Criar um back-end replicado para o aplicativo Bookshelf.
  • Criar um serviço com balanceamento de carga que encaminhe o tráfego HTTP para o front-end do Bookshelf.

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. Ativar Cloud Datastore API, GKE API, Cloud Storage API, Cloud Pub/Sub API APIs.

    Ativar a de APIs

  5. Instale e inicialize o SDK do Cloud.
  6. Instale o Docker. Ele será usado para criar imagens de contêiner localmente.
  7. Instale o kubectl.
    gcloud components install kubectl

Como criar um cluster do GKE

Um cluster do GKE é um conjunto gerenciado de máquinas virtuais (VMs, na sigla em inglês) do Compute Engine que operam como uma única unidade. Para este tutorial, você precisa de um cluster que tenha no mínimo dois nós com acesso a todas as APIs do Google.

  1. Crie o cluster. Substitua [YOUR_GCP_ZONE] pela zona do GCP em que você quer hospedar o cluster.

    gcloud container clusters create bookshelf \
        --scopes "cloud-platform,userinfo-email" \
        --num-nodes 2 \
        --enable-basic-auth \
        --issue-client-certificate \
        --enable-ip-alias \
        --zone [YOUR_GCP_ZONE]
    
  2. Verifique se você tem acesso ao cluster. O comando a seguir lista os nós do cluster de contêiner e indica se ele está sendo executado e se você tem acesso a ele.

    kubectl get nodes
    

Use o comando kubectl para criar recursos em um cluster do GKE. Para saber mais sobre kubectl, consulte Operações de cluster do GKE. Para gerenciar os recursos, você normalmente usará o gcloud no projeto do GCP e kubectl no cluster do GKE. Um único projeto pode conter vários clusters, o que facilita o uso de clusters compostos por diferentes tipos de máquinas para necessidades distintas.

Ao criar um cluster com gcloud, a autenticação é automaticamente definida para kubectl. Se você usar o Console do Google Cloud Platform para criar clusters, será possível configurar a autenticação. Basta usar o comando gcloud container clusters get-credentials.

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/optional-kubernetes-engine
    

Como inicializar o Cloud Datastore

O aplicativo Bookshelf usa o Cloud Datastore para armazenar os livros. Para inicializar o Cloud Datastore no seu projeto pela primeira vez, faça o seguinte:

  1. No Console do GCP, abra a página do Cloud Datastore.

    Acessar a página do Cloud Datastore

  2. Selecione uma região para o armazenamento de dados e clique em Continuar até chegar à página Criar uma entidade. Em seguida, feche a janela porque o aplicativo Bookshelf estará pronto para criar entidades no Cloud Datastore.

Como criar um intervalo do Cloud Storage

O aplicativo Bookshelf usa o Cloud Storage para armazenar arquivos de imagem.

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 criar um tópico e uma assinatura do Cloud Pub/Sub

O aplicativo Bookshelf usa o Cloud Pub/Sub para armazenar solicitações de da API Google Books sobre livros adicionados ao Bookshelf.

  1. Crie um novo tópico do Cloud Pub/Sub usando o seguinte comando do SDK do Cloud, em que [YOUR_PUBSUB_TOPIC] representa o nome desse tópico.

    gcloud pubsub topics create [YOUR_PUBSUB_TOPIC]
    
  2. Crie uma nova assinatura do Cloud Pub/Sub para o tópico criado na etapa anterior, em que [YOUR_PUBSUB_SUBSCRIPTION] representa essa assinatura.

    gcloud pubsub subscriptions create --topic [YOUR_PUBSUB_TOPIC] [YOUR_PUBSUB_SUBSCRIPTION]
    

Como configurar o aplicativo

  1. Copie os arquivos de configuração de exemplo para criar versões personalizadas. Eles estão em .gitignore e não recebem efetivação para controle de versão.

    cp config/database.example.yml config/database.yml
    cp config/settings.example.yml config/settings.yml
    
  2. Abra config/database.yml para editá-lo e substitua [YOUR_PROJECT_ID] pelo código do projeto.

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

    • [YOUR_PROJECT_ID] pelo código do projeto;
    • [YOUR_PUBSUB_TOPIC] pelo tópico do Cloud Pub/Sub;
    • [YOUR_PUBSUB_SUBSCRIPTION] pela inscrição do Cloud Pub/Sub;
    • [YOUR_BUCKET_NAME] pelo nome do intervalo criado na etapa anterior;
    • [YOUR_CLIENT_ID] pelo código do cliente do OAuth;
    • [YOUR_CLIENT_SECRET] pela chave secreta do cliente do OAuth.

Como contentorizar o aplicativo

O aplicativo de amostra inclui um Dockerfile, que será usado para criar a imagem de Docker do aplicativo. Essa imagem executa o aplicativo no GKE.

# The Google App Engine Ruby runtime is Debian Jessie with Ruby installed
# and various os-level packages to allow installation of popular Ruby
# gems. The source is on github at:
#   https://github.com/GoogleCloudPlatform/ruby-docker
FROM gcr.io/google_appengine/ruby

# Install 2.4.3 if not already preinstalled by the base image
RUN cd /rbenv/plugins/ruby-build && \
    git pull && \
    rbenv install -s 2.4.3 && \
    rbenv global 2.4.3 && \
    gem install -q --no-rdoc --no-ri bundler --version 1.16.1
ENV RBENV_VERSION 2.4.3

# Copy the application files.
COPY . /app/

# Install required gems.
RUN bundle install --deployment && rbenv rehash

# Set environment variables.
ENV RACK_ENV=production \
    RAILS_ENV=production \
    RAILS_SERVE_STATIC_FILES=true

# Run asset pipeline.
RUN bundle exec rake assets:precompile

# Reset entrypoint to override base image.
ENTRYPOINT []

# Use foreman to start processes. $FORMATION will be set in the pod
# manifest. Formations are defined in Procfile.
CMD bundle exec foreman start --formation "$FORMATION"
O aplicativo de amostra também tem um arquivo .dockerignore que lista os caminhos de arquivo que não estão incluídos no contêiner resultante do Docker. Normalmente, esse arquivo inclui artefatos de versão e instalações de dependência local.

# Copyright 2015, Google, Inc.
# 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
#
#    http://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.

.git
log/*
tmp/*
  1. Crie a imagem do Docker do aplicativo.

    docker build -t gcr.io/[YOUR_PROJECT_ID]/bookshelf
    
  2. Encaminhe a imagem para o Container Registry. Dessa forma, o cluster poderá acessá-la.

    gcloud docker -- push gcr.io/[YOUR_PROJECT_ID]/bookshelf
    

Como implantar o front-end do Bookshelf

O aplicativo Bookshelf tem um servidor de front-end que gerencia as solicitações da Web e um worker de back-end que processa os livros e adiciona informações complementares.

Os recursos do cluster necessários para executar o front-end são definidos em bookshelf-frontend.yaml. Esses recursos são descritos como uma implantação do GKE. Use as implementações para criar e atualizar uma réplica definida e os respectivos pods.

# Copyright 2016, Google, Inc.
# 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
#
#    http://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.

# This file configures the bookshelf application frontend. The frontend serves
# public web traffic.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: bookshelf-frontend
  labels:
    app: bookshelf
    tier: frontend
# The bookshelf frontend replica set ensures that at least 3
# instances of the bookshelf app are running on the cluster.
# For more info about Pods see:
#   https://cloud.google.com/kubernetes-engine/docs/pods/
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: bookshelf
        tier: frontend
    spec:
      containers:
      - name: bookshelf-app
        # Replace [YOUR_PROJECT_ID] with your project ID.
        image: gcr.io/[YOUR_PROJECT_ID]/bookshelf:latest
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        # The FORMATION environment variable is used by foreman in the
        # Dockerfile's CMD to control which processes are started. In this
        # case, only the bookshelf process is needed.
        env:
        - name: FORMATION
          value: web=1
        # The bookshelf process listens on port 8080 for web traffic by default.
        ports:
        - name: http-server
          containerPort: 8080
  1. No arquivo bookshelf-frontend.yaml, substitua [YOUR_PROJECT_ID] pelo código do projeto.

  2. Implante os recursos no cluster.

    kubectl create -f bookshelf-frontend.yaml
    
  3. Monitore o status da implantação.

    kubectl get deployments
    

    Assim que a implantação tiver o número desejado de pods, ela será concluída. Caso tenha problemas, exclua essa implantação e comece novamente.

    kubectl delete deployments bookshelf-frontend
    
  4. Após a conclusão da implantação, você conseguirá ver os pods criados por ela.

    kubectl get pods
    

Como implantar o back-end do Bookshelf

O back-end e o front-end do Bookshelf são implantados da mesma maneira.

# Copyright 2016, Google, Inc.
# 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
#
#    http://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.

# This file configures the bookshelf worker. The worker processes
# jobs in the background.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: bookshelf-worker
  labels:
    app: bookshelf
    tier: worker
# The bookshelf worker replica set ensures that at least 2
# instances of the bookshelf worker are running on the cluster.
# For more info about Pods see:
#   https://cloud.google.com/kubernetes-engine/docs/pods/
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: bookshelf
        tier: worker
    spec:
      containers:
      - name: bookshelf-worker
        # Replace [YOUR_PROJECT_ID] with your project ID.
        image: gcr.io/[YOUR_PROJECT_ID]/bookshelf:latest
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        # The FORMATION environment variable is used by foreman in the
        # Dockerfile's CMD to control which processes are started. In this
        # case, only the worker process is needed.
        env:
        - name: FORMATION
          value: worker=1
  1. No arquivo bookshelf-worker.yaml, substitua [YOUR_PROJECT_ID] pelo código do projeto.

  2. Implante os recursos no cluster.

    kubectl create -f bookshelf-worker.yaml
    
  3. Verifique se os pods estão em execução.

    kubectl get pods
    

Como criar o serviço do Bookshelf

Os serviços do GKE fornecem um único ponto de acesso a um conjunto de pods. Ainda que seja possível acessar um único pod, eles são temporários. Por isso, é melhor atribuir um conjunto de pods a um único endpoint. No aplicativo Bookshelf, os pods de front-end podem ser acessados a partir de um único endereço IP. Esse serviço é definido em bookshelf-service.yaml.

# Copyright 2016, Google, Inc.
# 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
#
#    http://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.

# The bookshelf service provides a load-balancing proxy over the bookshelf
# frontend pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine
# will create an external HTTP load balancer.
# For more information about Services see:
#   https://cloud.google.com/kubernetes-engine/docs/services/
# For more information about external HTTP load balancing see:
#   https://cloud.google.com/kubernetes-engine/docs/load-balancer
apiVersion: v1
kind: Service
metadata:
  name: bookshelf-frontend
  labels:
    app: bookshelf
    tier: frontend
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: http-server
  selector:
    app: bookshelf
    tier: frontend

Observe que os pods e o serviço que utiliza esses pods são separados. No Kubernetes, você usa etiquetas para selecionar os pods atendidos por um serviço. Com isso, você tem um serviço que inclui pods de diferentes conjuntos de réplicas e vários serviços que apontam para um pod específico.

  1. Crie o serviço do Bookshelf.

    kubectl create -f bookshelf-service.yaml
    
  2. Consiga o endereço IP externo do serviço.

    kubectl describe service bookshelf
    

    Pode levar até um minuto para alocar o endereço IP. O endereço IP externo está listado em LoadBalancer Ingress.

Como acessar o aplicativo Bookshelf

Você implantou todos os recursos necessários para executar o aplicativo Bookshelf no GKE. Use o endereço IP externo da etapa anterior para carregar o aplicativo no navegador da Web e criar livros.

Se você tiver implantado o worker, os livros serão atualizados automaticamente com informações da API Google Books.

Como fazer a limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform, é possível fazer o seguinte:

Excluir o 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 o que você quer excluir e clique em Excluir projeto. Após marcar a caixa de seleção ao lado do nome do projeto, clique em Excluir projeto
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Excluir o cluster

A exclusão do cluster remove todos os recursos do GKE e do Compute Engine. No entanto, é necessário remover manualmente todos os recursos no Cloud Storage, no Cloud Datastore e no Cloud Pub/Sub.

Exclua o cluster usando o comando a seguir e substitua [YOUR_GCP_ZONE] pela zona usada na criação do cluster.

gcloud container clusters delete bookshelf --zone [YOUR_GCP_ZONE]

A seguir

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

Enviar comentários sobre…