Como executar o Bookshelf em Java no Compute Engine

Neste tutorial, você aprenderá a executar o aplicativo Bookshelf em Java no Google Compute Engine. Siga as etapas para implantar um aplicativo da Web Java no Compute Engine. Não é preciso conhecer o app Bookshelf para seguir este tutorial. Caso queira saber mais sobre ele, consulte o tutorial do ambiente flexível do App Engine.

Objetivos

  • Implantar o app de amostra Bookshelf em uma única instância do Compute Engine.
  • Escalonar o app horizontalmente usando um grupo de instâncias gerenciadas.
  • Veicular o tráfego usando o balanceamento de carga HTTP.
  • Responder a mudanças de tráfego usando o escalonamento automático.

Custos

Neste tutorial, há componentes do Cloud Platform que podem ser faturáveis, entre eles os seguintes:

  • Google Compute Engine
  • Google Cloud Storage
  • Google Cloud Datastore
  • Google Cloud Logging
  • Google Cloud Pub/Sub

Use a Calculadora de preços para gerar uma estimativa de custo com base na projeção de uso. 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 Java 8 e o Maven.

Como criar um intervalo do Cloud Storage

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.

Para criar um intervalo:

  1. Chame o seguinte comando em uma janela de terminal:

    gsutil mb gs://[YOUR-BUCKET-NAME]

  2. Configure a lista de controle de acesso (ACL, na sigla em inglês) padrão do intervalo como public-read para que os usuários vejam as imagens que eles enviaram por upload:

    gsutil defacl set public-read gs://[YOUR-BUCKET-NAME]

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. Acesse o diretório da amostra:

    cd getting-started-java/bookshelf/6-gce
    

Como configurar o app

  1. Abra makeBookshelf para edição.
  2. Defina a variável BUCKET com o nome do intervalo criado anteriormente.
  3. Também é possível alterar ZONE=us-central1-f para uma zona diferente.
  4. Torne o script executável: chmod +x makeBookshelf.
  5. Abra pom.xml para edição.
  6. Defina a propriedade bookshelf.bucket com o nome do intervalo.
  7. Salve e feche os dois arquivos.

    Como executar o aplicativo no computador local

    1. Inicie um servidor da Web local:

      mvn -Plocal clean jetty:run-exploded -DprojectID=[YOUR-PROJECT-ID]
      

      em que [YOUR-PROJECT-ID] é o código do projeto.

    2. No navegador da Web, digite este endereço:

      http://localhost:8080

    Para interromper o servidor da Web local, pressione Control+C.

    Como implantar em uma instância única

    Implantação de instância única

    Esta seção ensina a executar uma única instância do aplicativo no Compute Engine.

    Como enviar o código para um repositório

    Há diversas maneiras de colocar um código em uma instância do Compute Engine em execução. Uma delas é usar o Cloud Source Repositories. Você pode criar com facilidade um repositório Git no seu projeto e carregar o código do aplicativo nele. Assim, as instâncias podem extrair a versão mais recente desse código a partir do repositório durante a inicialização. Isso é conveniente porque não é preciso configurar novas imagens ou instâncias para atualizar o aplicativo. Basta reiniciar ou criar uma instância.

    Insira este comando para criar uma instância do Compute Engine e envie o aplicativo para ela:

    ./makeBookshelf gce
    

    O comando faz o seguinte:

    • Desenvolve o projeto e cria um arquivo WAR de Java.
    • Faz upload do arquivo WAR e de alguns scripts para o intervalo do Cloud Storage criado anteriormente para armazenar imagens.
    • Cria uma instância do Compute Engine e permite que ela acesse o Cloud Logging, o Cloud Storage e o Cloud Datastore.
    • Transmite metadados sobre o intervalo do Cloud Storage.
    • Especifica o script de inicialização.
    mvn clean package
    
    gsutil cp -r target/${WAR} gce/base gs://${BUCKET}/gce/
    
    gcloud compute firewall-rules create allow-http-bookshelf \
      --allow tcp:80 \
      --source-ranges 0.0.0.0/0 \
      --target-tags ${TAGS} \
      --description "Allow port 80 access to instances tagged with ${TAGS}"
    
    gcloud compute instances create my-app-instance \
      --machine-type=${MACHINE_TYPE} \
      --scopes=${SCOPES} \
      --metadata-from-file startup-script=${STARTUP_SCRIPT} \
      --zone=${ZONE} \
      --tags=${TAGS} \
      --image-family=${IMAGE_FAMILY} \
      --image-project=${IMAGE_PROJECT} \
      --metadata BUCKET=${BUCKET}

    O script makeBookshelf define diversas variáveis:

    ZONE=us-central1-f
    
    GROUP=frontend-group
    TEMPLATE=$GROUP-tmpl
    MACHINE_TYPE=g1-small
    IMAGE_FAMILY=debian-8
    IMAGE_PROJECT=debian-cloud
    STARTUP_SCRIPT=gce/startup-script.sh
    SCOPES="datastore,userinfo-email,logging-write,storage-full,cloud-platform"
    TAGS=http-server
    
    MIN_INSTANCES=1
    MAX_INSTANCES=10
    TARGET_UTILIZATION=0.6
    
    SERVICE=frontend-web-service
    WAR=bookshelf-1.0-SNAPSHOT.war

    A instância levará cerca de cinco minutos para executar o script de inicialização. Verifique o andamento da criação da instância digitando este comando:

    gcloud compute instances get-serial-port-output my-app-instance --zone us-central1-f
    

    Depois que o script de inicialização é concluído, você pode verificar os registros na nova instância em /var/logs/daemon.log.

    O nome da instância é my-app-instance. Para saber o endereço IP externo da instância, digite este comando:

    gcloud compute instances list
    

    Para ver a execução do aplicativo, insira este URL no navegador:

    http://[YOUR_INSTANCE_IP]
    

    Para excluir a instância, digite o seguinte comando:

    ./makeBookshelf down
    

    Este comando faz o mesmo:

    gcloud compute instances delete my-app-instance
    

    Como usar um script para inicializar uma instância

    Agora que o código pode ser acessado pelas instâncias do Compute Engine, você precisa configurar sua instância para que o download e a execução do código sejam feitos. Isso pode ser feito por meio de um script de inicialização que é executado sempre que a instância for iniciada ou reiniciada.

    Este é um exemplo de script de inicialização que executa as seguintes tarefas:

    • Instala o Java 8 e o torna padrão.

    • Instala e configura Jetty.

    • Copia o arquivo WAR Java do intervalo do Cloud Storage para o webapps do Jetty e o renomeia como root.war. Como isso o torna o servlet raiz, ele não precisa ser nomeado no URL.

    • Instala o agente do Google Cloud Logging e o configura para monitorar os registros do aplicativo. Isso significa que será feito o upload dos registros configurados nas etapas anteriores deste tutorial, exatamente como se você estivesse usando o ambiente flexível do App Engine.

    set -e
    set -v
    
    # Talk to the metadata server to get the project id
    PROJECTID=$(curl -s "http://metadata.google.internal/computeMetadata/v1/project/project-id" -H "Metadata-Flavor: Google")
    BUCKET=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/BUCKET" -H "Metadata-Flavor: Google")
    
    echo "Project ID: ${PROJECTID}  Bucket: ${BUCKET}"
    
    # get our file(s)
    gsutil cp "gs://${BUCKET}/gce/"** .
    
    # Install dependencies from apt
    apt-get update
    apt-get install -t jessie-backports -yq openjdk-8-jdk
    
    # Make Java8 the default
    update-alternatives --set java /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java
    
    # Jetty Setup
    mkdir -p /opt/jetty/temp
    mkdir -p /var/log/jetty
    
    # Get Jetty
    curl -L https://repo1.maven.org/maven2/org/eclipse/jetty/jetty-distribution/9.3.8.v20160314/jetty-distribution-9.3.8.v20160314.tar.gz -o jetty9.tgz
    tar xf jetty9.tgz  --strip-components=1 -C /opt/jetty
    
    # Add a Jetty User
    useradd --user-group --shell /bin/false --home-dir /opt/jetty/temp jetty
    
    cd /opt/jetty
    # Add running as "jetty"
    java -jar /opt/jetty/start.jar --add-to-startd=setuid
    cd /
    
    # very important - by renaming the war to root.war, it will run as the root servlet.
    mv bookshelf-1.0-SNAPSHOT.war /opt/jetty/webapps/root.war
    
    # Make sure "jetty" owns everything.
    chown --recursive jetty /opt/jetty
    
    # Configure the default paths for the Jetty service
    cp /opt/jetty/bin/jetty.sh /etc/init.d/jetty
    echo "JETTY_HOME=/opt/jetty" > /etc/default/jetty
    {
      echo "JETTY_BASE=/opt/jetty"
      echo "TMPDIR=/opt/jetty/temp"
      echo "JAVA_OPTIONS=-Djetty.http.port=80"
      echo "JETTY_LOGS=/var/log/jetty"
    } >> /etc/default/jetty
    
    # -Dorg.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.JavaUtilLog
    
    # Reload daemon to pick up new service
    systemctl daemon-reload
    
    # Install logging monitor. The monitor will automatically pickup logs sent to syslog.
    curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
    service google-fluentd restart &
    
    service jetty start
    service jetty check
    
    echo "Startup Complete"

    Como criar e configurar uma instância do Compute Engine

    1. Crie uma instância do Compute Engine:

      Linux/Mac OS X

      gcloud compute instances create my-app-instance \
          --image-family=debian-8 \
          --image-project=debian-cloud \
          --machine-type=g1-small \
          --scopes userinfo-email,cloud-platform \
          --metadata-from-file startup-script=gce/startup-script.sh \
          --zone us-central1-f \
          --tags http-server
      

      Windows

      gcloud compute instances create my-app-instance ^
          --image-family=debian-8 ^
          --image-project=debian-cloud ^
          --machine-type=g1-small ^
          --scopes userinfo-email,cloud-platform ^
          --metadata-from-file startup-script=gce/startup-script.sh ^
          --zone us-central1-f ^
          --tags http-server
      

      Com este comando, uma nova instância é criada, o acesso aos serviços do Cloud Platform é concedido e o script de inicialização é executado. O nome da instância é my-app-instance.

    2. Verifique o andamento da criação da instância:

      gcloud compute instances get-serial-port-output my-app-instance --zone us-central1-f
      

      Se o script de inicialização for concluído, você verá Finished running startup script no final da saída do comando.

    3. Crie uma regra de firewall para permitir o tráfego da instância:

      Linux/Mac OS X

      gcloud compute firewall-rules create default-allow-http-8080 \
          --allow tcp:8080 \
          --source-ranges 0.0.0.0/0 \
          --target-tags http-server \
          --description "Allow port 8080 access to http-server"
      

      Windows

      gcloud compute firewall-rules create default-allow-http-8080 ^
          --allow tcp:8080 ^
          --source-ranges 0.0.0.0/0 ^
          --target-tags http-server ^
          --description "Allow port 8080 access to http-server"
      

    4. Consulte o endereço IP externo da instância:

      gcloud compute instances list
      
    5. Para ver o aplicativo em execução, acesse http://[YOUR_INSTANCE_IP]:8080,

      em que [YOUR_INSTANCE_IP] é o endereço IP externo da instância.

    Como gerenciar e monitorar uma instância

    Use o Console do Google Cloud Platform para monitorar e gerenciar a instância. Na seção Computação > Compute Engine, você vê a instância em execução e faz a conexão usando o SSH. Na seção Monitoramento > Registros, você vê todos os registros gerados pelos recursos do Compute Engine. O Google Cloud Logging é configurado automaticamente para reunir os registros de diversos serviços em comum, inclusive o syslog.

    Escalonamento horizontal com diversas instâncias

    Implantação de várias instâncias com instâncias gerenciadas

    No Compute Engine, o escalonamento horizontal é feito sem nenhuma dificuldade. Com um grupo de instâncias gerenciadas e o autoescalador do Compute Engine, as novas instâncias do aplicativo são criadas automaticamente quando necessárias. Quando a demanda é baixa, elas são encerradas. Configure um balanceador de carga HTTP para distribuir o tráfego entre as instâncias de um grupo gerenciado.

    Como criar um grupo de instâncias gerenciadas

    Um grupo de instâncias gerenciadas é composto de instâncias homogêneas que têm o mesmo modelo como base. Esse modelo define a configuração da instância, incluindo imagem de origem, tamanho do disco, escopos e metadados, além de scripts de inicialização.

    1. Primeiro, crie um modelo:

      ./makeBookshelf gce-many
      

    2. Em seguida, crie um grupo de instâncias:

      gcloud compute instance-groups managed \
        create ${GROUP} \
        --base-instance-name ${GROUP} \
        --size ${MIN_INSTANCES} \
        --template ${TEMPLATE} \
        --zone ${ZONE}

      No parâmetro --size, o número de instâncias do grupo é especificado. Após a execução dos scripts de inicialização terminar em todas as instâncias, elas podem ser acessadas individualmente, usando os endereços IP externos e a porta 8080. Para consultar os endereços IP externos das instâncias, digite gcloud compute instances list. Os nomes das instâncias gerenciadas começam com o mesmo prefixo my-app, especificado no parâmetro --base-instance-name.

    Como criar um balanceador de carga

    Uma instância individual é ideal para testes ou depuração. Entretanto, para veicular o tráfego da Web, é mais recomendável usar um balanceador de carga, pois ele direciona o tráfego automaticamente para as instâncias disponíveis. Para criar um balanceador, siga as etapas abaixo.

    1. Crie uma verificação de integridade. Essa verificação é feita no balanceador de carga para determinar as instâncias capazes de veicular o tráfego:

      gcloud compute http-health-checks create ah-health-check \
        --request-path /_ah/health \
        --port 80

    2. Crie uma porta nomeada. O balanceador de carga HTTP verifica o serviço http para determinar qual porta recebe o tráfego. No grupo de instâncias existentes, nomeie a porta 8080 como http:

    3. Crie um serviço de back-end. Esse serviço é o destino do tráfego com carga balanceada. Ele define o grupo de instâncias para onde o tráfego deve ser direcionado e qual verificação de integridade deve ser usada.

      gcloud compute backend-services create $SERVICE \
        --http-health-checks ah-health-check

    4. Adicione o serviço de back-end:

      gcloud compute backend-services add-backend $SERVICE \
        --instance-group $GROUP \
        --zone $ZONE

    5. Crie um mapa de URLs e um proxy:

      O mapa de URLs define quais URLs são direcionados aos respectivos serviços de back-end. Nesta amostra, todo o tráfego é veiculado por um serviço de back-end. Se você quer fazer o balanceamento de carga entre diversas regiões ou grupos, crie vários serviços. Em um proxy, o tráfego é recebido e encaminhado para os serviços com esses mapas.

      1. Crie o mapa de URLs:

        gcloud compute url-maps create $SERVICE-map \
          --default-service $SERVICE

      2. Crie o proxy:

        gcloud compute target-http-proxies create $SERVICE-proxy \
          --url-map $SERVICE-map

    6. Crie uma regra de encaminhamento global. Com essa regra, é possível vincular um endereço IP público e uma porta a um proxy:

      gcloud compute forwarding-rules create $SERVICE-http-rule \
        --global \
        --target-http-proxy $SERVICE-proxy \
        --port-range 80

    Como configurar o autoescalador

    Com o balanceador de carga, você garante que o tráfego seja distribuído para todas as instâncias íntegras. Mas o que acontece quando há muito tráfego para as instâncias processarem? Uma saída seria adicioná-las manualmente. No entanto, a melhor solução é configurar um autoescalador do Compute Engine para criar e excluir automaticamente as instâncias de acordo com a demanda de tráfego.

    1. Crie um autoescalador:

      gcloud compute instance-groups managed set-autoscaling \
        $GROUP \
        --max-num-replicas $MAX_INSTANCES \
        --target-load-balancing-utilization $TARGET_UTILIZATION \
        --zone $ZONE

      Com o comando anterior, um autoescalador é criado no grupo de instâncias gerenciado. Ele tem a capacidade de fazer o escalonamento automático de até 10 instâncias. Quando o balanceador de carga ultrapassa 50% de utilização, novas instâncias são adicionadas e, quando fica abaixo de 50%, elas são removidas.

    2. Crie uma regra de firewall caso ainda não tenha criado uma:

      Linux/Mac OS X

      gcloud compute firewall-rules create default-allow-http-8080 \
          --allow tcp:8080 \
          --source-ranges 0.0.0.0/0 \
          --target-tags http-server \
          --description "Allow port 8080 access to http-server"
      

      Windows

      gcloud compute firewall-rules create default-allow-http-8080 ^
          --allow tcp:8080 ^
          --source-ranges 0.0.0.0/0 ^
          --target-tags http-server ^
          --description "Allow port 8080 access to http-server"
      

    3. Verifique o andamento:

      gcloud compute backend-services get-health my-app-service
      

      Continue verificando até que pelo menos uma das instâncias fique com o status HEALTHY.

    Como ver o aplicativo

    1. Consulte o endereço IP de encaminhamento para o balanceador de carga:

      gcloud compute forwarding-rules list --global
      

      O endereço IP das regras de encaminhamento está na coluna IP_ADDRESS.

    2. Em um navegador, digite o endereço IP da lista. Agora, o aplicativo com carga balanceada e escalonamento automático está em execução no Google Compute Engine.

    Como gerenciar e monitorar a implantação

    Gerenciar diversas instâncias é tão fácil quanto uma única instância. Use o console do GCP para monitorar o balanceamento de carga, o escalonamento automático e o grupo de instâncias gerenciadas.

    Gerencie o grupo de instâncias e a configuração de escalonamento automático na seção Computação > Compute Engine > Grupos de instâncias.

    Gerencie a configuração do balanceamento de carga, incluindo mapas de URLs e serviços de back-end, na seção Computar > Compute Engine > Balanceamento de carga HTTP.

    Script de implantação

    O aplicativo de amostra inclui um script que ajuda a demonstrar a implantação no Compute Engine. O script deploy.sh faz uma implantação completa do aplicativo com carga balanceada e escalonamento automático, conforme descrito em Escalonamento horizontal com diversas instâncias.

Como fazer a limpeza

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

Como executar o script de desmontagem

Se tiver usado deploy.sh, execute o script teardown.sh para remover todos os recursos criados pelo deploy.sh. Isso coloca seu projeto no estado em que estava antes de executar deploy.sh e evita cobranças adicionais. Para remover a única instância e o intervalo de armazenamento criados no início do tutorial, siga as instruções na próxima seção.

Como excluir recursos manualmente

Se você seguiu as etapas manuais deste tutorial, exclua as instâncias do Compute Engine e o intervalo do Cloud Storage manualmente.

Como excluir a instância do Compute Engine

Para excluir uma instância do Compute Engine:

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

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

  2. Clique na caixa de seleção ao lado da da instância que deseja excluir.
  3. Clique no botão Excluir na parte superior da página para excluir a instância.

Como excluir o intervalo do Cloud Storage

Para excluir um intervalo do Cloud Storage:

  1. No Console do GCP, acesse o navegador do Cloud Storage.

    Acessar o navegador do Cloud Storage

  2. Marque a caixa de seleção ao lado do intervalo que você quer excluir.
  3. Para excluir o intervalo, clique no botão Excluir no topo da página.

Próximas etapas

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

Enviar comentários sobre…