Como executar o Bookshelf em Java no Kubernetes Engine

Neste tutorial, você aprenderá a executar o aplicativo Bookshelf em Java no Kubernetes Engine. Acompanhe as instruções para inserir um aplicativo da Web em Java em um contêiner e implantá-lo no Kubernetes Engine. Não é preciso conhecer o aplicativo Bookshelf para seguir esse tutorial. No entanto, se você quiser saber mais sobre ele, consulte o tutorial do App Engine Flexible.

Objetivos

  • Criar um cluster do Kubernetes Engine.
  • Inserir um aplicativo Java em contêiner.
  • Criar um front-end replicado para o aplicativo Bookshelf.
  • Criar um serviço com de balanceamento de carga que encaminhe o tráfego HTTP para o front-end do Bookshelf.

Custos

Este tutorial usa componentes faturáveis do Cloud Platform, incluindo:

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

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto. Novos usuários do Cloud Platform podem se qualificar para uma 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 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, Cloud Storage e Cloud Pub/Sub APIs.

    Ativar as APIs

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

Como criar um cluster do Kubernetes Engine

Um cluster do Kubernetes Engine é um conjunto gerenciado de máquinas virtuais do Compute Engine, operado como um único cluster Kubernetes. Para este tutorial, precisaremos de um cluster com um mínimo de dois nodes, e esses nodes precisarão acessar todas as APIs do Google. Substitua [YOUR_GCP_ZONE] pela zona do Cloud Platform onde você quer que seu cluster seja hospedado.

  1. Crie o cluster:

    gcloud container clusters create bookshelf \
        --scopes "cloud-platform" \
        --num-nodes 2 \
        --zone [YOUR_GCP_ZONE]
    
  2. Verifique se você tem acesso ao cluster:

    kubectl get nodes
    

    A execução desse comando lista os nodes no cluster do contêiner. Além disso, indica que o cluster está funcionando e que você pode acessá-lo.

Use o comando kubectl para criar recursos em um cluster do Kubernetes Engine. Para saber mais sobre o kubectl, consulte a página Operações do cluster do Kubernetes Engine. Para gerenciar recursos, você normalmente usará o gcloud no projeto do Google Cloud e o kubectl no cluster do Kubernetes Engine. Um 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 o gcloud, ele configura automaticamente a autenticação do kubectl. Os clusters criados com o Cloud Console podem configurar a autenticação usando 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-java.

  1. Clone o repositório:

    git clone https://github.com/GoogleCloudPlatform/getting-started-java.git
    
  2. Navegue até o diretório de amostra:

    cd getting-started-java/bookshelf/optional-kubernetes-engine
    

Como inicializar o Datastore

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

  1. Abra o Datastore no Console do GCP.

  2. Selecione uma região para o armazenamento de dados e clique em Continuar. Quando acessar a página "Criar uma entidade", você poderá fechar a janela porque o Bookshelf estará pronto para criar entidades no Datastore.

Como criar um intervalo do Cloud Storage

No aplicativo Bookshelf, o Google Cloud Storage é usado para armazenar arquivos de imagens.

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

Dê ao intervalo um nome igual ao código do projeto.

Para criar um intervalo:

  1. Chame o comando a seguir:

    gsutil mb gs://[YOUR-PROJECT-ID]

    Substitua [YOUR-PROJECT-ID] pelo código do projeto.

  2. Defina a Access Control List padrão do intervalo como public-read para permitir que os usuários visualizem as imagens que eles enviaram:

    gsutil defacl set public-read gs://[YOUR-PROJECT-ID]

    Substitua [YOUR-PROJECT-ID] pelo código do projeto.

Como inserir o aplicativo em contêiner

O aplicativo de amostra inclui um Dockerfile, usado para criar a imagem Docker do aplicativo. Essa imagem é usada para executar o aplicativo no Kubernetes Engine.

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

# Add application code.
ADD target/bookshelf-gke-1.0-SNAPSHOT/ /app

Primeiro, empacote o aplicativo Bookshelf:

mvn clean -DprojectID=<your-project-id> package

Crie a imagem Docker do aplicativo:

docker build -t gcr.io/[YOUR_PROJECT_ID]/bookshelf .

Envie a imagem ao Google Container Registry para que ela possa ser acessada pelo cluster:

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

Como implantar o front-end do Bookshelf

O aplicativo Bookshelf é composto por um conjunto de servidores front-end que manipula e processa as solicitações da Web.

Os recursos do cluster necessários para executar o front-end são definidos em bookshelf-frontend.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 2017 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/kubernetes-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.
        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
  1. Em bookshelf-frontend.yaml, substitua [GCLOUD_PROJECT] pelo código do projeto.
  2. Use o kubectl para implantar os recursos no cluster:

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

    kubectl get deployments
    

    Quando tiver o número desejado 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{{yamlsuffix}
    
  4. Após a conclusão da implantação, você conseguirá ver os pods criados por ela:

    kubectl get pods
    

Como criar o serviço Bookshelf

Os serviços do Kubernetes são usados para fornecer um único ponto de acesso para um conjunto de pods. Embora seja possível acessar um único pod, eles são temporários. Por isso, é melhor atribuir um conjunto de pods a um único ponto de extremidade. 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 2017 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 marcadores 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 Bookshelf:

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

    kubectl describe service bookshelf
    

    Observe que pode levar até 60 segundos para o IP ser alocado. Ele aparecerá listado em LoadBalancer Ingress.

Como acessar o aplicativo Bookshelf

Agora todos os recursos necessários para executar o aplicativo Bookshelf no Kubernetes Engine foram implantados. Use o endereço IP externo da etapa anterior para carregar o aplicativo no navegador da Web e criar livros.

Como fazer a limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform:

Como excluir o projeto

A maneira mais fácil de evitar a cobrança é excluir o projeto criado 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.

Como excluir o cluster

Com a exclusão do cluster, você remove todos os recursos do Kubernetes Engine e do Compute Engine. No entanto, os recursos do Cloud Storage, Cloud Datastore e Cloud Pub/Sub precisam ser removidos manualmente.

Exclua o cluster usando o comando abaixo. Substitua [YOUR_GCP_ZONE] pela zona que você usou ao criar o cluster.

gcloud container clusters delete bookshelf --zone [YOUR_GCP_ZONE]

Próximas etapas

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

Enviar comentários sobre…