Como implantar a Plataforma Pega usando o Compute Engine e o Cloud SQL

Neste tutorial, mostramos como implantar a Plataforma Pega no Google Cloud. Ele será útil para administradores de sistemas, desenvolvedores ou engenheiros interessados nos detalhes do processo de implantação.

A Plataforma Pega é uma plataforma de gerenciamento de processos de negócios (BPM, na sigla em inglês) e de gerenciamento de relacionamento com o cliente (CRM, na sigla em inglês). Empresas e agências usam a Pega para criar rapidamente aplicativos empresariais que proporcionem os resultados e as experiências completas de que os clientes precisam.

Neste guia, pressupomos que você esteja familiarizado, mesmo que no nível básico, com o Cloud Shell, o Cloud SQL, o Compute Engine e a linha de comando do Linux.

Visão geral

A Plataforma Pega é um aplicativo corporativo compatível com Java Enterprise Edition e composto de duas camadas:

  • O aplicativo da Plataforma Pega é hospedado nos servidores de aplicativos que também fazem a interconexão com outros sistemas.
  • Regras, dados e objetos de trabalho gerados e usados pela Plataforma Pega são armazenados nos servidores de banco de dados.

Usuários e desenvolvedores de aplicativos normalmente acessam a Plataforma Pega por meio de um navegador da Web.

Serviços baseados em HTTP, como SOAP ou REST, também podem ser expostos pelos aplicativos para a administração ou automatização de processos em um ambiente sem comando.

Neste tutorial, mostramos o seguinte:

  • Uma arquitetura de referência para implantar um aplicativo Pega escalonável no Google Cloud que seja adequado para um ambiente para desenvolvedores. Suas necessidades de infraestrutura e segurança variam, assim, é possível ajustar de forma adequada as configurações descritas neste tutorial.
  • Um repositório do GitHub com os scripts usados no tutorial para instalar a Plataforma Pega e outros componentes necessários.
  • Instruções sobre como testar a mídia de instalação da Plataforma Pega 7.4 e implantar scripts e a arquitetura de referência.
  • Instruções de como configurar a Plataforma Pega para compatibilidade com o Cloud Load Balancing.

No final deste tutorial, você terá um cluster da Pega com uma instância do Cloud SQL para PostgreSQL e três máquinas virtuais (VM, na sigla em inglês) de aplicativos em cluster do Compute Engine, gerenciados pelo Cloud Load Balancing para tráfego da Web. Todas as conexões SQL são feitas por meio do Cloud SQL Proxy. Neste tutorial, usaremos a região us-central1 para a implantação da Pega.

Os produtos a seguir são usados neste tutorial. Se você usar versões diferentes deles, pode precisar fazer ajustes nos scripts e comandos mencionados e nos repositórios.

  • Plataforma Pega 7.4
  • PostgreSQL 9.6
  • Red Hat Enterprise Linux 7
  • Apache Tomcat 8.5

No diagrama a seguir, mostramos a arquitetura da implantação da Pega discutida neste tutorial.

Arquitetura de implantação da Pega

Objetivos

  • Implantar o PostgreSQL usando o Cloud SQL.
  • Configurar a Pega.
  • Instalar o Pega Rulebase.
  • Instalar os servidores de aplicativos da Pega.
  • Use o Cloud Logging e o Cloud Monitoring para geraão de relatórios de erros e monitoramento durante a instalação.

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

  • Compute Engine
  • Persistent Disk
  • Cloud SQL
  • Cloud Storage
  • Rede

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Antes de começar

  1. Verifique se você tem o arquivo de mídia de instalação da Pega 7.4. Se ainda não tiver, entre em contato com o Suporte da Pega.
  2. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  3. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar a página do seletor de projetos

  4. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  5. Ative as APIs Compute Engine, Cloud SQL Admin, Logging, and Monitoring.

    Ative as APIs

Use o Cloud Shell para todos os comandos do terminal neste tutorial. Ao concluir o tutorial, exclua os recursos criados para evitar a continuidade do faturamento. Veja mais detalhes em Como fazer a limpeza.

Preparar o ambiente

Nesta seção, você fará as configurações padrão para valores usados no tutorial, como região e zona. Neste tutorial, use us-central1 como a região padrão e us-central1-b como a zona padrão.

Você também criará um arquivo com todas as configurações para poder carregar as variáveis automaticamente se precisar reabrir o Cloud Shell e reinicializar as configurações.

  1. Abra o Cloud Shell:

    Abra o Cloud Shell

  2. Defina a região e a zona padrão:

    gcloud compute project-info add-metadata \
        --metadata google-compute-default-region=us-central1,google-compute-default-zone=us-central1-b
  3. Reinicie o shell:

    gcloud init --console-only

    Pressione 1 para as três primeiras perguntas e insira o código do projeto para a última pergunta.

  4. Defina uma variável de ambiente para manter o nome do bucket do Cloud Storage que você criará posteriormente neste tutorial. Substitua [BUCKET_NAME] pelo nome escolhido. Siga as regras para nomes de bucket do Cloud Storage. Para mais detalhes, consulte as Diretrizes de nomenclatura de intervalo.

    GCS_BUCKET=[BUCKET_NAME]
  5. Defina uma variável de ambiente para manter o nome do arquivo de instalação da Pega 7.4. O arquivo de instalação que você recebe da Pega é um arquivo ZIP. O nome dele contém um número exclusivo. No exemplo a seguir, substitua [NNNNN] por esse número.

    PEGA_INSTALL_FILENAME=[NNNNN]_Pega7.4.zip
  6. Defina uma variável de ambiente para manter o nome da instância do Cloud SQL. Siga as regras para nomes de instâncias. Eles precisam começar com uma letra e só podem conter letras minúsculas, números e hifens.

    CLOUD_SQL_INSTANCE_NAME=[INSTANCE_NAME]
  7. Defina uma variável de ambiente para manter a senha de usuário administrador do banco de dados da Pega:

    ADMIN_USER_PW=[ADMIN_PASSWORD]
  8. Defina uma variável de ambiente para manter a senha de usuário base do banco de dados da Pega:

    BASE_USER_PW=[PEGA_DATABASE_PASSWORD]
  9. Defina uma variável de ambiente para manter o valor inicial da sua senha de administrador da Pega (administrator@pega.com):

    PEGA_ADMIN_PW=[PEGA_ADMIN_PASSWORD]
  10. Defina uma variável de ambiente para manter a região padrão:

    REGION=$(gcloud compute project-info describe \
        --format 'value(commonInstanceMetadata.google-compute-default-region)')
  11. Crie um arquivo com as variáveis de ambiente:

    cat <<EOF > ~/.pegarc
    GCS_BUCKET=${GCS_BUCKET}
    PEGA_INSTALL_FILENAME=${PEGA_INSTALL_FILENAME}
    CLOUD_SQL_INSTANCE_NAME=${CLOUD_SQL_INSTANCE_NAME}
    ADMIN_USER_PW=${ADMIN_USER_PW}
    BASE_USER_PW=${BASE_USER_PW}
    PEGA_ADMIN_PW=${PEGA_ADMIN_PW}
    REGION=${REGION}
    EOF
  12. Carregue as variáveis de ambiente na sessão atual e configure o Cloud Shell para carregar automaticamente as variáveis em logins futuros:

    grep -q -F "source ~/.pegarc" ~/.bashrc || echo "source ~/.pegarc" >> ~/.bashrc

Como configurar a conta de serviço

Para permitir que a Pega tenha acesso aos recursos do tutorial, crie uma conta de serviço do Google Cloud. Essa conta precisa dos papéis a seguir:

  • cloudsql.client. Usado para se conectar ao banco de dados do Cloud SQL por meio do Cloud SQL Proxy.
  • storage.objectViewer. Usado para fazer o download de arquivos do Cloud Storage.
  • logging.logWriter. Usado para gravar registros no Cloud Logging.
  • monitoring.metricWriter. Usado para gravar dados de monitoramento no Cloud Monitoring.
  • errorreporting.writer. Usado para gravar informações de erro no Cloud Logging.

Para criar a conta de serviço:

  1. No Cloud Shell, crie uma conta de serviço chamada pega-app:

    gcloud iam service-accounts create pega-app --display-name "pega-app"
  2. Adicione os papéis à conta de serviço:

    gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
        --member=serviceAccount:pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --role=roles/cloudsql.client
    gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
        --member=serviceAccount:pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --role=roles/storage.objectViewer
    gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
        --member=serviceAccount:pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --role=roles/logging.logWriter
    gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
        --member=serviceAccount:pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --role=roles/monitoring.metricWriter
    gcloud projects add-iam-policy-binding ${DEVSHELL_PROJECT_ID} \
        --member=serviceAccount:pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --role=roles/errorreporting.writer

Configurar o Cloud SQL

A próxima etapa é criar um banco de dados. Para este tutorial, você usa um banco de dados PostgreSQL no Cloud SQL.

  1. No Cloud Shell, crie a instância do Cloud SQL:

    gcloud sql instances create ${CLOUD_SQL_INSTANCE_NAME} \
        --database-version=POSTGRES_9_6 --cpu=2 --region=${REGION} \
        --memory=8GB --storage-auto-increase --backup-start-time=00:00 \
        --availability-type=regional

    Neste tutorial, você usa uma instância com duas vCPUs e 8 GB de RAM. Essa etapa pode levar alguns minutos para ser concluída.

  2. Crie os usuários do ambiente de execução da Pega para sua instalação usando uma configuração de usuário duplo. Nessa configuração, um usuário administrador recebe privilégios totais para o banco de dados, e um usuário base recebe um subconjunto menor.

    gcloud sql users create PegaADMIN \
        --instance=${CLOUD_SQL_INSTANCE_NAME}  \
        --password=${ADMIN_USER_PW}
    gcloud sql users create PegaBASE \
        --instance=${CLOUD_SQL_INSTANCE_NAME}  \
        --password=${BASE_USER_PW}

Como configurar um bucket do Cloud Storage

Você precisa criar um bucket do Cloud Storage que tenha a mídia de instalação da Pega e outros scripts usados neste tutorial.

  1. No Cloud Shell, crie o bucket:

    gsutil mb -c regional -l ${REGION} gs://${GCS_BUCKET}
  2. Usando o Console do Cloud, faça upload do arquivo zip de instalação da Pega 7.4 para o novo bucket de armazenamento. Faça o upload do arquivo para a raiz do novo bucket.

Como fazer upload dos scripts de instalação para um bucket do Cloud Storage

Agora, faça o download do repositório de origem do GitHub que faz parte dessa solução para sua instância do Cloud Shell. Em seguida, faça o upload do repositório para um bucket do Cloud Storage.

  1. No Cloud Shell, faça o download do arquivo ZIP que contém os scripts de instalação do repositório do GitHub:

    wget https://github.com/GoogleCloudPlatform/solutions-compute-cloudsql-pega7/archive/master.zip
  2. Descompacte o conteúdo do arquivo:

    unzip master.zip
  3. Faça o upload dos scripts para seu bucket:

    gsutil cp -rP solutions-compute-cloudsql-pega7-master/ gs://${GCS_BUCKET}/scripts

Instalar o Pega Rulebase

O Pega Rulebase armazena regras, itens de trabalho e outros dados que a Pega usa para as respectivas operações. Para instalar o Pega Rulebase, configure uma VM temporária do Compute Engine para executar os scripts de instalação da Pega. Use um script de inicialização que tenha configurações pré-configuradas para não precisar executar comandos de instalação manualmente. Nesta etapa, o script de inicialização é usado, mas também é possível executar a instalação manualmente.

O script de instalação do Pega Rulebase é responsável pelas seguintes ações:

  • Execução de atualizações do sistema
  • Instalação dos agentes do Cloud Logging e do Cloud Monitoring.
  • Instalação dos pacotes necessários, como o cliente PostgreSQL e o Java Development Kit (JDK).
  • Instalação e configuração do Cloud SQL Proxy para se conectar à instância do Cloud SQL.
  • Download e descompactação do arquivo de instalação da Pega no bucket do Cloud Storage.
  • Preenchimento do arquivo setupDatabase.properties, que contém as variáveis de ambiente necessárias
  • Download do driver JDBC do PostgreSQL
  • Criação dos esquemas da Pega no banco de dados.
  • Execução do script de instalação do Pega Rulebase.

Para instalar o Pega Rulebase, faça o seguinte:

  1. No Cloud Shell, crie a VM que inclui o script de inicialização da instalação do Pega Rulebase:

    gcloud compute instances create pega-db-installer \
        --machine-type=n1-standard-4 \
        --service-account=pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --scopes=https://www.googleapis.com/auth/cloud-platform \
        --image-family rhel-7  \
        --image-project=rhel-cloud \
        --boot-disk-size=35GB \
        --metadata=startup-script-url=gs://${GCS_BUCKET}/scripts/pega/db-startup.sh,SQL_INSTANCE_ID=${CLOUD_SQL_INSTANCE_NAME},GCS_BUCKET=${GCS_BUCKET},PEGA_INSTALL_FILENAME=${PEGA_INSTALL_FILENAME},ADMIN_USER_PW=${ADMIN_USER_PW},BASE_USER_PW=${BASE_USER_PW},PEGA_ADMIN_PW=${PEGA_ADMIN_PW}

    Esse processo pode levar até uma hora.

    Dica: é possível criar as regras de firewall e de modelo de instância nas duas seções a seguir, enquanto a instalação da Pega está em execução.

  2. Verifique o status da instalação. Para isso, visualize o registro do script de inicialização.

    1. Acesse o console do Cloud Logging:

      Console do Cloud Logging

    2. Na lista suspensa, selecione a instância do Compute Engine com o nome pega-db-installer.

    3. Pesquise startup-script-url para filtrar apenas as mensagens de registro do script de inicialização.

      Quando a linha de registro exibir Your Pega installation is complete!, vá para a próxima etapa.

  3. Exclua a instância da VM de instalação:

    gcloud compute instances delete pega-db-installer

Criar regras de firewall

Você precisa criar algumas regras de firewall para permitir o tráfego de e para os servidores de aplicativos criados. Posteriormente neste tutorial, você anexará a tag de rede pega-app às suas VMs e, em seguida, configurará as regras de firewall.

Para uma implantação da Pega, é preciso permitir os seguintes tipos de tráfego, conforme definido no Guia de instalação da Pega (em inglês):

  • Comunicação de clustering Pega Hazelcast. Para isso, são usadas as portas TCP 5701 a 5800 entre cada servidor de aplicativos Pega no cluster.
  • Comunicação nó a nó do Pega ElasticSearch. Para isso, são usadas as portas TCP 9300 a 9399 entre cada servidor de aplicativos Pega no cluster.
  • Porta 8080 ou 8443 para o tráfego dos usuários ou os intervalos de endereços IP do Cloud Load Balancing. Isso permite que o tráfego da Web alcance sua instalação da Pega. Os balanceadores de carga globais têm os seguintes intervalos de IP de origem:

    130.211.0.0/22
    35.191.0.0/16

Para criar regras de firewall:

  1. Permita o tráfego de qualquer VM com a tag de rede pega-app para qualquer outra VM com a tag pega-app:

    gcloud compute firewall-rules create pega-internal \
        --description="Pega node to node communication requirements" \
        --action=ALLOW \
        --rules=tcp:9300-9399,tcp:5701-5800 \
        --source-tags=pega-app \
        --target-tags=pega-app
  2. Permita o tráfego do balanceador de carga global para qualquer VM que tenha a tag de rede pega-app:

    gcloud compute firewall-rules create pega-web-external \
        --description="Pega external web ports" \
        --action=ALLOW \
        --rules=tcp:8080,tcp:8443 \
        --source-ranges=130.211.0.0/22,35.191.0.0/16 \
        --target-tags=pega-app

Como criar o modelo de instância para os servidores de aplicativos

Para criar um cluster da Pega com alta disponibilidade, use grupos de instâncias para definir o local, a capacidade e a elasticidade do cluster e modelos de instâncias para garantir que as VMs executem, cada uma, a mesma configuração.

Neste tutorial, você usa o tipo de máquina n1-standard-2, que tem 2 vCPUs e 7,5 GB de RAM. Para mais informações, consulte a documentação sobre os tipos de máquina do Google Cloud. Ajuste suas configurações de acordo com os requisitos do ambiente.

  • Crie o modelo da instância:

    gcloud compute instance-templates create pega-app \
        --machine-type=n1-standard-2 \
        --service-account=pega-app@${DEVSHELL_PROJECT_ID}.iam.gserviceaccount.com \
        --scopes=https://www.googleapis.com/auth/cloud-platform \
        --tags=pega-app --image-family rhel-7 --image-project=rhel-cloud \
        --boot-disk-size=20GB \
        --metadata=startup-script-url=gs://${GCS_BUCKET}/scripts/pega/app-startup.sh,SQL_INSTANCE_ID=${CLOUD_SQL_INSTANCE_NAME},GCS_BUCKET=${GCS_BUCKET},PEGA_INSTALL_FILENAME=${PEGA_INSTALL_FILENAME},ADMIN_USER_PW=${ADMIN_USER_PW},BASE_USER_PW=${BASE_USER_PW},PEGA_ADMIN_PW=${PEGA_ADMIN_PW}

O script de instalação do servidor de aplicativos da Pega é responsável pelas seguintes tarefas:

  • Instalação das atualizações mais recentes do sistema
  • Instalação dos agentes do Cloud Logging e do Cloud Monitoring.
  • Instalação do JDK
  • Instalação e configuração do Cloud SQL Proxy para se conectar à instância do Cloud SQL e executá-lo como um serviço.
  • Instalação do Tomcat.
  • Download do driver JDBC do PostgreSQL.
  • Configuração do Tomcat com as definições exigidas pela Pega.
  • Download da mídia de instalação da Pega a partir do bucket do Cloud Storage e instalação dos arquivos do aplicativo da Web da Pega para o Tomcat.
  • Inicialização do Tomcat e da Pega.

Criar o grupo de instâncias

Depois de criar o modelo da instância, crie um grupo de instâncias que use os modelos de VM criados anteriormente.

Neste tutorial, você cria um grupo de instâncias com três VMs. O grupo não é escalonado automaticamente. No entanto, as VMs são recriadas se alguma delas for encerrada.

  1. Crie um grupo de instâncias gerenciadas:

    gcloud compute instance-groups managed create "pega-app" \
        --base-instance-name "pega-app" \
        --template "pega-app" \
        --size "3" \
        --region=${REGION}

    Esse comando cria um grupo de instância chamado pega-app com três VMs.

  2. Crie uma porta chamada:

    gcloud compute instance-groups managed set-named-ports pega-app \
        --named-ports=pega-web:8080 \
        --region=${REGION}

As respectivas VMs começam a ser criadas automaticamente pelo grupo de instâncias.

Criar o balanceador de carga

Para fornecer aos usuários acesso aos servidores de aplicativos Pega, é preciso criar um balanceador de carga para distribuir o tráfego da Web entre as VMs do grupo de instâncias. Um balanceador de carga é uma combinação de vários componentes, incluindo o seguinte:

  • uma regra de encaminhamento global (front-end);
  • um proxy de destino;
  • um mapa do URL;
  • um serviço de back-end com um ou mais back-ends;
  • uma verificação de integridade para definir se os serviços de back-end estão íntegros.

Para criar o balanceador de carga:

  1. No Cloud Shell, crie a verificação de integridade:

    gcloud compute health-checks create http pega-health \
        --request-path=/prweb/PRRestService/monitor/pingservice/ping \
        --port=8080

    Com isso, a verificação de integridade é configurada para monitorar o serviço de ping fornecido pela Pega, que informa se a instância da Pega está em execução. Para saber detalhes, consulte Como verificar se uma instância está em execução.

  2. Crie o serviço de back-end:

    gcloud compute backend-services create pega-app \
        --health-checks=pega-health \
        --port-name=pega-web \
        --session-affinity=GENERATED_COOKIE \
        --protocol=HTTP --global

    O serviço de back-end define as verificações de integridade que testam se as instâncias estão íntegras e também permite definir políticas de balanceamento de carga.

  3. Adicione um back-end ao serviço de back-end:

    gcloud compute backend-services add-backend pega-app \
        --instance-group=pega-app \
        --global \
        --instance-group-region=${REGION}

    O back-end define para qual grupo de instâncias esse tráfego é roteado.

  4. Crie o mapa de URL:

    gcloud compute url-maps create pega-app --default-service=pega-app

    Esse comando define um mapa de URL padrão para o roteamento de todo o tráfego para o serviço de back-end que você criou. Em uma arquitetura mais complexa, é possível rotear o tráfego com padrões de URL diferentes para outros serviços de back-end.

  5. Crie o proxy de destino:

    gcloud compute target-http-proxies create pega-app --url-map=pega-app
  6. Crie um endereço IP estático:

    gcloud compute addresses create pega-app --global

    Esse comando cria um endereço IP estático que pode ser usado para correlação com um registro do sistema de nomes de domínio (DNS). Se preferir um endereço IP temporário, pule esta etapa e omita a opção --address da regra de encaminhamento global na próxima etapa.

  7. Crie a regra de encaminhamento global do front-end:

    gcloud compute forwarding-rules create pega-app \
        --global \
        --address=$(gcloud compute addresses describe pega-app --global --format 'value(address)') \
        --ip-protocol=TCP \
        --ports=80 \
        --target-http-proxy=pega-app

Conectar-se ao aplicativo da Pega

Pode levar de 5 a 10 minutos para o grupo de instâncias se tornar disponível pela primeira vez. Nesta seção, você verifica se a implantação é lançada e acessa a página de login principal.

  1. Para verificar o status do seu balanceador de carga, acesse a página Balanceamento de carga no Console do Cloud.

    Abrir a página "Balanceamento de carga"

    Quando a implantação estiver pronta, na coluna Back-ends, você verá um ícone de status verde ao lado do nome do balanceador de carga.

  2. Encontre o endereço IP que você atribuiu ao balanceador de carga:

    gcloud compute forwarding-rules describe pega-app --global
  3. Copie e cole o endereço IP no seu navegador usando a sintaxe a seguir. Substitua [IP_ADDRESS] pelo endereço IP que você recebeu na etapa anterior.

    http://[IP_ADDRESS]/prweb

Como configurar a implantação da Pega

Para dar suporte completo ao balanceador de carga, você precisa criar configurações dinâmicas do sistema ("Dynamic System Settings"). Isso informa à Pega qual cookie procurar quando um administrador desativa um nó da Pega, além de garantir que os usuários finais mantenham suas sessões da Web adequadamente.

Você precisa criar duas configurações do sistema para ativar esse recurso. Neste tutorial, são usadas as Dynamic System Settings, que permitem criar as configurações apenas uma vez para um cluster inteiro.

Dica: também é possível importar as configurações usando o Assistente de importação de aplicativos. Para mais detalhes, consulte Próximas etapas.

  1. Em uma janela do navegador, faça login no console da Pega usando seu nome de usuário administrator@pega.com e a senha (PEGA_ADMIN_PW) que você definiu na seçãoComo preparar seu ambiente.

    Você receberá uma solicitação para alterar a senha na primeira vez em que fizer login.

  2. No console da Pega, clique em Create > SysAdmin > Dynamic System Settings.

  3. Na página Create Dynamic System Settings, defina as seguintes configurações:

    • Descrição curta: prconfig/session/ha/quiesce/customSessionInvalidationMethod
    • Owning Ruleset: Pega-Engine
    • Setting Purpose: prconfig/session/ha/quiesce/customSessionInvalidationMethod
  4. Clique em Create and open.

  5. Defina o campo de valor como configurable-cookie-invalidator e clique em Save.

  6. Clique na seta para baixo à direita de Save e em Save As.

    Opção "Save As" para Dynamic Systems Settings

  7. Crie outra configuração com os seguintes valores:

    • Short Description: prconfig/session/ha/quiesce/cookieToInvalidate
    • Owning Ruleset: Pega-Engine
    • Setting Purpose: prconfig/session/ha/quiesce/cookieToInvalidate
  8. Clique em Create and open.

  9. Defina o campo de valor como GCLB e clique em Save.

  10. No Cloud Shell, execute uma reinicialização contínua para o grupo de instâncias:

    gcloud beta compute instance-groups managed rolling-action \
        restart pega-app \
        --region=${REGION}

    Quando todos os servidores de aplicativos estiverem on-line, a implantação estará concluída.

Para mais informações sobre como configurar a afinidade da sessão na Pega, confira as referências na Documentação de ajuda da Pega no PDN (em inglês).

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que contém os recursos ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir