Déployer la plate-forme Pega à l'aide de Compute Engine et de Cloud SQL

Ce tutoriel vous explique comment déployer la plate-forme Pega sur Google Cloud. Il vous sera utile si vous êtes administrateur système, développeur ou ingénieur, et que vous vous intéressez aux détails du processus de déploiement.

La plate-forme Pega est une plate-forme de gestion des processus métier (BPM, Business Process Management) et de gestion de la relation client (CRM, Customer Relationship Management). Pega aide les entreprises et les agences à créer rapidement des applications métier offrant les résultats et l'expérience client de bout en bout dont elles ont besoin.

Dans ce guide, nous supposons que vous connaissez les principes de base de Cloud Shell, Cloud SQL, Compute Engine et de la ligne de commande Linux.

Présentation

La plate-forme Pega est une application d'entreprise compatible avec Java EE composée de deux couches :

  • Les serveurs d'applications hébergent l'application de la plate-forme Pega et assurent l'interconnectivité avec d'autres systèmes.
  • Les serveurs de base de données stockent les règles, les données et les objets de travail employés et générés par la plate-forme Pega.

Les développeurs et les utilisateurs d'applications accèdent généralement à la plate-forme Pega via un navigateur Web.

Les applications peuvent également exposer des services basés sur HTTP, tels que des services SOAP ou REST, à des fins d'administration ou de traitement de l'automatisation dans un environnement sans interface graphique.

Ce tutoriel fournit les éléments suivants :

  • Une architecture de référence pour la mise en œuvre d'une application Pega évolutive sur Google Cloud adaptée à un environnement de développement. Comme vos besoins en infrastructure et en sécurité varient, vous pouvez ajuster les configurations décrites dans ce tutoriel en conséquence.
  • Un dépôt GitHub contenant les scripts que vous exécutez dans le tutoriel pour installer Pega et les autres composants requis.
  • Des instructions pour la préparation du support d'installation de la plate-forme Pega 7.4, ainsi que pour le déploiement de scripts et de l'architecture de référence.
  • Des instructions concernant la configuration de Pega pour assurer sa compatibilité avec Cloud Load Balancing.

À la fin de ce tutoriel, vous disposerez d'un cluster Pega doté d'une seule instance Cloud SQL pour PostgreSQL et de trois machines virtuelles (VM) d'application Compute Engine en cluster, appuyé par Cloud Load Balancing pour le trafic Web. Toutes les connexions SQL sont établies à l'aide du proxy Cloud SQL. Ce tutoriel utilise la région us-central1 pour le déploiement de Pega.

Les produits suivants sont utilisés dans ce tutoriel. Si vous utilisez des versions différentes de ces produits, vous devrez peut-être modifier les scripts et les commandes référencés dans ce tutoriel et dans les dépôts.

  • Plate-forme Pega 7.4
  • PostgreSQL 9.6
  • Red Hat Enterprise Linux 7
  • Apache Tomcat 8.5

Le schéma suivant illustre l'architecture du déploiement Pega décrit dans ce tutoriel.

Architecture du déploiement de Pega

Objectifs

  • Déployer PostgreSQL à l'aide de Cloud SQL.
  • Configurer Pega.
  • Installer la base de règles Pega.
  • Installer les serveurs d'applications Pega.
  • Créer des rapports d'erreur et surveiller les erreurs pendant l'installation à l'aide de Cloud Logging et Cloud Monitoring.

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • Compute Engine
  • Persistent Disk
  • Cloud SQL
  • Cloud Storage
  • Réseau

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Avant de commencer

  1. Vérifiez que vous disposez du fichier de support d'installation de Pega 7.4. Si ce n'est pas le cas, contactez l'assistance Pega.
  2. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  3. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  4. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  5. Activer les API Compute Engine, Cloud SQL Admin, Logging, and Monitoring.

    Activer les API

Utilisez Cloud Shell pour toutes les commandes de terminal de ce tutoriel. Une fois que vous avez terminé ce dernier, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Préparer votre environnement

Dans cette section, vous définissez des paramètres par défaut pour les valeurs utilisées tout au long du tutoriel, telles que la région et la zone. Dans ce tutoriel, la région par défaut est us-central1 et la zone par défaut est us-central1-b.

Vous devez également créer un fichier comprenant tous les paramètres, de façon à pouvoir charger les variables automatiquement si vous devez rouvrir Cloud Shell et réinitialiser les paramètres.

  1. Ouvrez Cloud Shell.

    Ouvrir Cloud Shell

  2. Définissez la région et la zone par défaut :

    gcloud compute project-info add-metadata \
        --metadata google-compute-default-region=us-central1,google-compute-default-zone=us-central1-b
  3. Réinitialisez l'interface système :

    gcloud init --console-only

    Appuyez sur 1 pour les trois premières questions, puis saisissez l'ID du projet pour la dernière question.

  4. Définissez une variable d'environnement destinée à contenir le nom du bucket Cloud Storage que vous créez plus loin dans ce tutoriel. Remplacez [BUCKET_NAME] par votre propre nom. Suivez les règles relatives aux noms de bucket Cloud Storage. Pour en savoir plus, consultez les consignes de dénomination des buckets.

    GCS_BUCKET=[BUCKET_NAME]
  5. Définissez une variable d'environnement destinée à contenir le nom du fichier d'installation Pega 7.4. Le fichier d'installation que vous obtenez de Pega est au format ZIP, et son nom contient un numéro unique. Dans l'exemple suivant, remplacez [NNNNN] par ce numéro.

    PEGA_INSTALL_FILENAME=[NNNNN]_Pega7.4.zip
  6. Définissez une variable d'environnement destinée à contenir le nom de l'instance Cloud SQL. Suivez les règles en matière de noms d'instance. Ceux-ci ne peuvent contenir que des lettres minuscules, des chiffres et des traits d'union, et doivent commencer par une lettre.

    CLOUD_SQL_INSTANCE_NAME=[INSTANCE_NAME]
  7. Définissez une variable d'environnement destinée à contenir le mot de passe administrateur Pega de base de données :

    ADMIN_USER_PW=[ADMIN_PASSWORD]
  8. Définissez une variable d'environnement destinée à contenir le mot de passe utilisateur de base Pega de votre base de données :

    BASE_USER_PW=[PEGA_DATABASE_PASSWORD]
  9. Définissez une variable d'environnement pour conserver la valeur initiale de votre mot de passe d'administrateur Pega (administrator@pega.com) :

    PEGA_ADMIN_PW=[PEGA_ADMIN_PASSWORD]
  10. Définissez une variable d'environnement destinée à contenir la région par défaut :

    REGION=$(gcloud compute project-info describe \
        --format 'value(commonInstanceMetadata.google-compute-default-region)')
  11. Créez un fichier contenant les variables d'environnement :

    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. Chargez les variables d'environnement dans la session en cours, puis configurez Cloud Shell pour qu'il les charge automatiquement lors de futures connexions :

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

Configurer le compte de service

Pour autoriser Pega à accéder aux ressources du didacticiel, vous devez créer un compte de service Google Cloud. Celui-ci a besoin des rôles suivants :

  • cloudsql.client. Permet de se connecter à la base de données Cloud SQL via le proxy Cloud SQL.
  • storage.objectViewer. Permet de télécharger des fichiers à partir de Cloud Storage.
  • logging.logWriter. Permet d'écrire des journaux dans Cloud Logging.
  • monitoring.metricWriter. Permet d'écrire des données de surveillance dans Cloud Monitoring.
  • errorreporting.writer. Permet d'écrire des informations sur les erreurs dans Cloud Logging.

Pour créer le compte de service :

  1. Dans Cloud Shell, créez un compte de service nommé pega-app :

    gcloud iam service-accounts create pega-app --display-name "pega-app"
  2. Ajoutez les rôles au compte de service :

    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

Configurer Cloud SQL

L'étape suivante consiste à créer une base de données. Dans le cadre de ce tutoriel, vous utilisez une base de données PostgreSQL sur Cloud SQL.

  1. Dans Cloud Shell, créez l'instance 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

    Dans ce tutoriel, vous utilisez une instance dotée de deux processeurs virtuels et de 8 Go de RAM. Cette étape peut prendre quelques minutes.

  2. Créez les utilisateurs d'exécution Pega pour votre installation à l'aide d'une configuration à deux utilisateurs. Dans ce type de configuration, un administrateur se voit attribuer des droits complets sur la base de données, et un utilisateur de base se voit attribuer un sous-ensemble de droits.

    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}

Configurer un bucket Cloud Storage

Vous devez créer un bucket Cloud Storage destiné à contenir le support d'installation Pega et les autres scripts exécutés dans ce tutoriel.

  1. Dans Cloud Shell, créez le bucket :

    gsutil mb -c regional -l ${REGION} gs://${GCS_BUCKET}
  2. À l'aide de Cloud Console, importez le fichier zip d'installation de Pega 7.4 dans le nouveau bucket de stockage. Importez le fichier à la racine du nouveau bucket.

Importer des scripts d'installation dans un bucket Cloud Storage

Téléchargez maintenant le dépôt source GitHub faisant partie de cette solution sur votre instance Cloud Shell. Vous pouvez ensuite importer le dépôt dans un bucket Cloud Storage.

  1. Dans Cloud Shell, téléchargez le fichier ZIP contenant les scripts d'installation à partir du dépôt GitHub :

    wget https://github.com/GoogleCloudPlatform/solutions-compute-cloudsql-pega7/archive/master.zip
  2. Décompressez le contenu du fichier :

    unzip master.zip
  3. Importez les scripts dans le bucket :

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

Installer la base de règles Pega

La base de règles Pega stocke les règles, les éléments de travail et d'autres données dont Pega se sert pour ses opérations. Pour installer la base de règles Pega, vous devez configurer une VM Compute Engine temporaire afin d'exécuter les scripts d'installation Pega. Vous pouvez employer un script de démarrage avec des paramètres préconfigurés pour ne pas avoir à exécuter manuellement les commandes d'installation. Dans cette étape, vous utilisez un script de démarrage, mais vous pouvez également effectuer l'installation manuellement.

Le script d'installation de la base de règles Pega effectue les actions suivantes :

  • Il exécute les mises à jour du système.
  • Il installe les agents Cloud Logging et Cloud Monitoring.
  • Il installe les packages requis, tels que le client PostgreSQL et le kit de développement Java (JDK).
  • Il installe et configure le proxy Cloud SQL pour se connecter à l'instance Cloud SQL.
  • Il télécharge et décompresse le fichier d'installation Pega à partir du bucket Cloud Storage.
  • Il remplit le fichier setupDatabase.properties contenant les variables d'environnement requises.
  • Il télécharge le pilote JDBC PostgreSQL.
  • Il crée les schémas Pega dans la base de données.
  • Il exécute le script d'installation de la base de règles Pega.

Pour installer la base de règles Pega :

  1. Dans Cloud Shell, créez la VM qui comprend le script de démarrage de l'installation de la base de règles Pega :

    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}

    Ce processus peut prendre jusqu'à une heure.

    Conseil : Vous pouvez créer les règles de pare-feu et le modèle d'instance dans les deux sections suivantes pendant l'installation de Pega.

  2. Vérifiez l'état de l'installation en affichant le journal du script de démarrage.

    1. Accédez à la console Cloud Logging :

      Console Cloud Logging

    2. Dans la liste déroulante, sélectionnez l'instance Compute Engine nommée pega-db-installer.

    3. Recherchez startup-script-url pour filtrer uniquement les messages de journal provenant du script de démarrage.

      Lorsque la ligne de journal affiche L'installation de Pega est terminée !, vous pouvez passer à l'étape suivante.

  3. Supprimez l'instance de VM d'installation :

    gcloud compute instances delete pega-db-installer

Créer des règles de pare-feu

Vous devez créer des règles de pare-feu pour autoriser le trafic en direction et en provenance des serveurs d'applications que vous créez. Plus loin dans ce tutoriel, vous associerez le tag réseau pega-app aux VM, puis vous configurerez les règles de pare-feu en conséquence.

Dans le cadre d'un déploiement de Pega, vous devez autoriser les types de trafic suivants, comme défini dans le guide d'installation Pega :

  • La communication par clustering Hazelcast Pega. Elle emploie les ports TCP 5701 à 5800 entre chaque serveur d'applications Pega du cluster.
  • La communication nœud à nœud ElasticSearch Pega. Elle emploie les ports TCP 9300 à 9399 entre chaque serveur d'applications Pega du cluster.
  • Le port 8080 ou 8443 pour le trafic généré par vos utilisateurs, ou les plages d'adresses IP de Cloud Load Balancing. Ceci permet au trafic Web d'atteindre votre installation Pega. Les équilibreurs de charge globaux ont les plages d'adresses IP source suivantes :

    130.211.0.0/22
    35.191.0.0/16

Pour créer des règles de pare-feu :

  1. Autorisez le trafic depuis n'importe quelle VM dotée du tag réseau pega-app vers toute autre VM dotée du tag réseau 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. Autorisez le trafic depuis l'équilibreur de charge global vers n'importe quelle VM dotée du tag réseau 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

Créer le modèle d'instance pour les serveurs d'applications

Pour créer un cluster Pega à disponibilité élevée, utilisez des groupes d'instances pour définir l'emplacement, la capacité et l'élasticité de ce dernier, ainsi que des modèles d'instance pour vous assurer que chaque VM exécute la même configuration.

Dans ce tutoriel, vous utilisez le type de machine n1-standard-2, qui dispose de deux processeurs virtuels et de 7,5 Go de RAM. Pour plus d'informations, consultez la documentation sur les types de machines Google Cloud. Ajustez les paramètres en conséquence, en fonction des exigences de votre environnement.

  • Créez le modèle d'instance :

    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}

Le script d'installation des serveurs d'applications Pega effectue les tâches suivantes :

  • Il installe les dernières mises à jour du système.
  • Il installe les agents Cloud Logging et Cloud Monitoring.
  • Il installe le JDK.
  • Il installe et configure le proxy Cloud SQL pour se connecter à l'instance Cloud SQL et l'exécuter en tant que service.
  • Il installe Tomcat.
  • Il télécharge le pilote JDBC PostgreSQL.
  • Il configure Tomcat avec les paramètres requis par Pega.
  • Il télécharge le support d'installation Pega à partir du bucket Cloud Storage, puis installe les archives d'applications Web Pega pour Tomcat.
  • Il démarre Tomcat et Pega.

Créer le groupe d'instances

Une fois le modèle d'instance généré, créez un groupe d'instances qui utilise les modèles de VM que vous avez générés précédemment.

Dans ce tutoriel, vous créez un groupe d'instances comportant trois VM. Le groupe ne fait pas l'objet d'un scaling automatique. Cependant, il recrée des VM si l'une d'entre elles s'arrête.

  1. Créez un groupe d'instances géré :

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

    Cette commande crée un groupe d'instances nommé pega-app qui comporte trois VM.

  2. Créez un port nommé :

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

Le groupe d'instances commence à créer automatiquement les VM.

Créer l'équilibreur de charge

Pour permettre aux utilisateurs d'accéder à vos serveurs d'applications Pega, vous devez créer un équilibreur de charge qui répartit le trafic Web entre les VM du groupe d'instances. Un équilibreur de charge est une combinaison de plusieurs composants, parmi lesquels :

  • Une règle de transfert globale (interface)
  • Un proxy cible
  • Un mappage d'URL
  • Un service de backend avec un ou plusieurs backends
  • Une vérification de l'état permettant de déterminer si les services de backend sont opérationnels.

Pour créer l'équilibreur de charge :

  1. Dans Cloud Shell, créez la vérification de l'état :

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

    Cette commande configure la vérification de l'état de façon à ce qu'elle surveille le service ping fourni par Pega, qui répond avec des informations indiquant si l'instance Pega est opérationnelle. Pour en savoir plus, consultez la page Verifying that an instance is running (Vérifier qu'une instance est opérationnelle).

  2. Créez le service de backend :

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

    Le service de backend définit des vérifications de l'état qui déterminent si les instances sont opérationnelles. Il vous permet également de définir des règles d'équilibrage de charge.

  3. Ajoutez un backend au service de backend :

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

    Le backend définit le groupe d'instances vers lequel le trafic est acheminé.

  4. Créez le mappage d'URL :

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

    Cette commande définit un mappage d'URL par défaut pour acheminer l'ensemble du trafic vers le service de backend que vous avez créé. Dans une architecture plus complexe, vous pouvez acheminer le trafic avec différents formats d'URL vers différents services de backend.

  5. Créez le proxy cible :

    gcloud compute target-http-proxies create pega-app --url-map=pega-app
  6. Créez une adresse IP statique :

    gcloud compute addresses create pega-app --global

    Cette commande crée une adresse IP statique que vous pouvez utiliser pour mapper un enregistrement de système de noms de domaine (DNS, Domain Name System). Si vous préférez utiliser une adresse IP éphémère, ignorez cette étape et omettez l'option --address dans la règle de transfert globale à l'étape suivante.

  7. Créez la règle de transfert globale d'interface :

    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

Se connecter à votre application Pega

Un délai de cinq à dix minutes peut s'écouler avant que le groupe d'instances ne soit disponible pour la première fois. Dans cette section, vous vérifiez que le déploiement est en ligne, puis vous accédez à la page de connexion principale.

  1. Pour vérifier l'état de votre équilibreur de charge, accédez à la page Équilibrage de charge dans Cloud Console.

    Ouvrir la page "Équilibrage de charge"

    Lorsque le déploiement est prêt, dans la colonne Backends, une icône d'état verte s'affiche en regard du nom de l'équilibreur de charge.

  2. Recherchez l'adresse IP que vous avez attribuée à l'équilibreur de charge :

    gcloud compute forwarding-rules describe pega-app --global
  3. Copiez et collez l'adresse IP dans votre navigateur en utilisant la syntaxe suivante. Remplacez [IP_ADDRESS] par l'adresse IP que vous avez obtenue à l'étape précédente.

    http://[IP_ADDRESS]/prweb

Configurer le déploiement de Pega

Pour assurer une compatibilité totale de l'équilibreur de charge, vous devez créer des paramètres système dynamiques. Cela indique à Pega le cookie à rechercher lorsqu'un administrateur suspend un nœud Pega, et garantit que les utilisateurs finaux gèrent leurs sessions Web correctement.

Vous devez créer deux paramètres système pour activer cette fonctionnalité. Dans ce tutoriel, vous utilisez des paramètres système dynamiques, ce qui vous permet de créer les paramètres une seule fois pour tout un cluster.

Conseil : Vous pouvez également importer les paramètres à l'aide de l'assistant d'importation d'applications. Pour en savoir plus, consultez la section Étapes suivantes.

  1. Dans une fenêtre de navigateur, connectez-vous à la console Pega à l'aide de votre nom d'utilisateur administrator@pega.com et du mot de passe (PEGA_ADMIN_PW) que vous avez défini dans la section Préparer votre environnement.

    Vous êtes invité à modifier le mot de passe la première fois que vous vous connectez.

  2. Dans la console Pega, cliquez sur Create (Créer) > SysAdmin (Administrateur système) > Dynamic System Settings (Paramètres système dynamiques).

  3. Sur la page Create Dynamic System Settings (Créer des paramètres système dynamiques), configurez les paramètres suivants :

    • Description courte : prconfig/session/ha/quiesce/customSessionInvalidationMethod
    • Ensemble de règles propriétaire : Pega-Engine
    • Définition du but : prconfig/session/ha/quiesce/customSessionInvalidationMethod
  4. Cliquez sur Create and open (Créer et ouvrir).

  5. Définissez le champ de valeur sur configurable-cookie-invalidator et cliquez sur Enregistrer.

  6. Cliquez sur la flèche vers le bas située à droite de Save (Enregistrer), puis sur Save As (Enregistrer sous).

    Option

  7. Créez un autre paramètre avec les valeurs suivantes :

    • Description courte : prconfig/session/ha/quiesce/cookieToInvalidate
    • Ensemble de règles propriétaire : Pega-Engine
    • Définition du but : prconfig/session/ha/quiesce/cookieToInvalidate
  8. Cliquez sur Create and open (Créer et ouvrir).

  9. Définissez le champ de valeur sur GCLB, puis cliquez sur Save (Enregistrer).

  10. Dans Cloud Shell, effectuez un redémarrage progressif pour le groupe d'instances :

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

    Lorsque tous vos serveurs d'applications sont de nouveau en ligne, le déploiement est terminé.

Pour en savoir plus sur la configuration de l'affinité de session dans Pega, consultez la documentation d'aide de Pega sur le PDN à titre de référence.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform, procédez comme suit :

Supprimer le projet

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes