Executar o Bookshelf em Node.js no Kubernetes Engine

Neste tutorial, você aprenderá a executar o aplicativo Bookshelf em Node.js no Google Kubernetes Engine (GKE). Siga estas instruções para implantar um aplicativo da Web em Node.js e colocá-lo em um contêiner no GKE. É recomendável que você use a documentação do aplicativo Bookshelf como parte do tutorial do ambiente padrão do App Engine.

Objetivos

  • Criar um cluster do GKE.
  • Inserir um app Node.js em um contêiner.
  • Criar um front-end replicado para o app 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, há componentes do Google Cloud Platform (GCP) que podem ser cobrados, inclusive estes:

  • GKE
  • Compute Engine
  • Cloud Storage
  • Cloud Datastore
  • Cloud Pub/Sub

Use a calculadora de preços para gerar uma estimativa de custo baseada na projeção de uso. Novos usuários do GCP podem aproveitar a avaliação gratuita.

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 Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar Cloud Datastore, Kubernetes Engine, Cloud Storage, Cloud Pub/Sub e Google+ APIs.

    Ativar as 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 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 onde você quer hospedar o cluster.

    gcloud container clusters create bookshelf \
        --scopes "cloud-platform" \
        --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 no cluster de contêiner, além de indicar que ele está funcionando e que você tem acesso a ele.

    kubectl get nodes
    

Use o comando kubectl para criar recursos em um cluster do GKE. Para saber mais sobre o kubectl, consulte Operações de cluster do GKE. Para gerenciar os recursos, você usará o gcloud no projeto do GCP e o 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 do kubectl será configurada automaticamente. No caso dos clusters criados no Console do Google Cloud Platform, é possível configurar a autenticação por meio do comando gcloud container clusters get-credentials.

Como clonar o app de amostra

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

  1. Clone o repositório.

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

    cd nodejs-getting-started/optional-kubernetes-engine
    

Como inicializar o Cloud Datastore

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

  1. No Console do GCP, abra o Cloud Datastore.

    Acessar o Cloud Datastore

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

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]

    Em que:

    • [YOUR-BUCKET-NAME] representa o nome do intervalo do Cloud Storage.
  2. Para visualizar imagens 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]

    Configurar o aplicativo

    No diretório de amostra, crie um arquivo config.json com este conteúdo:

    {
      "GCLOUD_PROJECT": "[YOUR_PROJECT_ID]",
      "CLOUD_BUCKET": "[YOUR_CLOUD_BUCKET]",
      "DATA_BACKEND": "datastore"
    }
    

    Substitua [YOUR_PROJECT_ID] pelo código do projeto, e [YOUR_CLOUD_BUCKET] pelo nome do intervalo do Cloud Storage.

    Colocar o aplicativo em um contêiner

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

    # Dockerfile extending the generic Node image with application files for a
    # single application.
    FROM gcr.io/google_appengine/nodejs
    
    # Check to see if the the version included in the base runtime satisfies
    # '>=8.12.0', if not then do an npm install of the latest available
    # version that satisfies it.
    RUN /usr/local/bin/install_node '>=8.12.0'
    COPY . /app/
    
    # You have to specify "--unsafe-perm" with npm install
    # when running as root.  Failing to do this can cause
    # install to appear to succeed even if a preinstall
    # script fails, and may have other adverse consequences
    # as well.
    # This command will also cat the npm-debug.log file after the
    # build, if it exists.
    RUN npm install --unsafe-perm || \
      ((if [ -f npm-debug.log ]; then \
          cat npm-debug.log; \
        fi) && false)
    CMD npm start
    
    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 2018 Google Inc. All Rights Reserved.
    #
    # 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.
    
    node_modules
    .dockerignore
    Dockerfile
    npm-debug.log
    .git
    .hg
    .svn
    
  3. Crie a imagem Docker do aplicativo.

    docker build -t gcr.io/[YOUR_PROJECT_ID]/bookshelf
    
  4. Envie a imagem ao Google Container Registry para que ela seja acessada pelo cluster:

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

Como implantar o front-end do Bookshelf

O app 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-datastore.yaml. Eles são conhecidos como Implantação do Kubernetes. Ela facilita a criação e a atualização de um conjunto de réplicas e dos pods associados a ele.

# Copyright 2018 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
# 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/container-engine/docs/pods/
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: bookshelf
        tier: frontend
    spec:
      containers:
      - name: bookshelf-app
        # Replace [GCLOUD_PROJECT] with your project ID or use `make template`.
        image: gcr.io/[GCLOUD_PROJECT]/bookshelf
        # 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 bookshelf process listens on port 8080 for web traffic by default.
        ports:
        - name: http-server
          containerPort: 8080
        env:
          - name: PROJECT_ID
            value: [GCLOUD_PROJECT]
  1. Em bookshelf-frontend-datastore.yaml, substitua [GCLOUD_PROJECT] pelo código do projeto.

  2. Implante os recursos no cluster.

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

    kubectl get deployments
    

    Quando tiver o número necessário de pods disponíveis, a implantação estará 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 2018 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 task worker. The worker is responsible
# for processing book requests and updating book information.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: bookshelf-worker
  labels:
    app: bookshelf
# The bookshelf worker replica set ensures that at least 2 instances of the
# bookshelf worker pod are running on the cluster.
# For more info about Pods see:
#   https://cloud.google.com/container-engine/docs/pods/
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: bookshelf
        tier: worker
    spec:
      containers:
      - name: bookshelf-app
        # Replace [GCLOUD_PROJECT] with your project ID or use `make template`.
        image: gcr.io/[GCLOUD_PROJECT]/bookshelf
        # 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 SCRIPT environment variable is used by `npm start` to control
        # which script is executed. This tells npm start to use `worker.js`
        # instead of the default `app.js`.
        env:
        - name: SCRIPT
          value: worker.js
        - name: PROJECT_ID
          value: [GCLOUD_PROJECT]
  1. Em bookshelf-worker-datastore.yaml, substitua [GCLOUD_PROJECT] pelo código do projeto.

  2. Implante os recursos no cluster.

    kubectl create -f bookshelf-worker-datastore.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 Kubernetes fornecem um único ponto de acesso para 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 endereço IP. Esse serviço é definido em bookshelf-service.yaml.

# Copyright 2018 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 estão separados. No Kubernetes, você usa rótulos para selecionar os pods abrangidos 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é 60 segundos para que o endereço IP seja alocado. 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.

Limpeza

Para evitar que os recursos usados nesse 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 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 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 abaixo. 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…