Déployer une application Java avec WebLogic Server sur un cluster Azure Kubernetes Service (AKS)

  • Article

Cet article montre comment :

  • Exécutez votre environnement Java, Java EE ou Jakarta EE sur Oracle WebLogic Server (WLS).
  • Mettez en place un cluster WLS à l'aide de l'offre Place de marché Azure.
  • Générez l'image Docker de l'application qui servira d'image auxiliaire pour fournir les modèles et les applications WebLogic Deploy Tooling (WDT).
  • Déployez l'application conteneurisée sur le cluster WLS existant sur AKS grâce à une connexion à Microsoft Azure SQL.

Cet article utilise l'offre Place de marché Azure pour WLS afin de d'accélérer votre parcours utilisateur vers l'AKS. L'offre approvisionne automatiquement plusieurs ressources Azure, notamment les ressources suivantes :

  • une instance Azure Container Registry
  • Un cluster AKS
  • une instance du contrôleur d'entrée Azure Application Gateway (AGIC)
  • l'opérateur WebLogic
  • une image conteneur comprenant le runtime WebLogic
  • un cluster WLS sans application

Ensuite, cet article présente la création d'une image auxiliaire étape par étape pour mettre à jour un cluster WLS existant. L'image auxiliaire fournit des modèles d'application et WDT.

Pour une automatisation complète, vous pouvez sélectionner votre application et configurer la connexion de source de données à partir du portail Microsoft Azure avant le déploiement de l'offre. Pour voir l’offre, visitez le Portail Azure.

Pour obtenir des instructions pas à pas sur la configuration de WebLogic Server sur Azure Kubernetes Service, consultez la documentation officielle d’Oracle sur Azure Kubernetes Service.

Prérequis

  • Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.
  • Vérifiez que l’identité Azure que vous utilisez pour vous connecter et compléter cet article a le rôle Propriétaire dans l’abonnement actuel ou les rôles Contributeur et Administrateur de l’accès utilisateur dans l’abonnement actuel. Pour obtenir une vue d’ensemble des rôles Azure, consultez Qu’est-ce que le contrôle d’accès en fonction du rôle Azure (RBAC Azure) ? Pour plus d’informations sur les rôles spécifiques requis par WLS sur AKS, consultez Rôles intégrés Azure.
  • Disposez des informations d’identification d’un compte d’authentification unique (SSO) Oracle. Pour en créer un, consultez la rubrique Créer votre compte Oracle.
  • Acceptez les termes du contrat de licence pour WLS.
    • Accédez à Oracle Container Registry et connectez-vous.
    • Si vous disposez d’un droit d’assistance, sélectionnez Intergiciel, puis recherchez et sélectionnez weblogic_cpu.
    • Si vous disposez d’un droit d’utilisation support, sélectionnez Intergiciel, puis recherchez et sélectionnez weblogic_cpu.

      Notes

      Obtenez un droit d’utilisation support auprès d’Oracle avant de passer en production. Si vous ne le faites pas, vous risquez d’exploiter des images non sécurisées qui ne sont pas corrigées pour les failles de sécurité critiques. Pour plus d’informations sur les mises à jour de correctifs critiques d’Oracle, consultez Mises à jour de correctifs critiques, alertes et bulletins de sécurité d’Oracle.

    • Acceptent le contrat de licence.
  • Préparez une machine locale avec un système d’exploitation de type Unix installé (par exemple Ubuntu, macOS, Sous-système Windows pour Linux).
    • Azure CLI. Utilisez az --version pour tester si az fonctionne. Ce document a été testé avec la version 2.55.1.
    • Docker. Ce document a été testé avec la version Docker 20.10.7. Utilisez docker info pour tester si le Docker Daemon est en cours d'exécution.
    • kubectl. Utilisez kubectl version pour tester si kubectl fonctionne. Ce document a été testé avec la version v1.21.2.
    • Un JDK Java compatible avec la version de WLS que vous vous envisagez exécuter. L'article vous recommande d'installer une version de WLS qui utilise le JDK 11. Azure recommande la version Microsoft Build d'OpenJDK. Assurez-vous que la variable d'environnement JAVA_HOME est correctement définie dans les interpréteurs de commandes dans lesquels vous exécutez les commandes.
    • Maven 3.5.0 ou une version plus récente.
    • Assurez-vous que l'utilitaire zip/unzip est installé. Utilisez zip/unzip -v pour vérifier si zip/unzip fonctionne.
  • Toutes les étapes de cet article, à l'exception de celles impliquant Docker, peuvent également être exécutées dans Azure Cloud Shell. Pour en savoir plus sur Azure Cloud Shell, consultez Qu'est-ce qu'Azure Cloud Shell ?

Déployer WLS sur AKS

Les étapes de cette section vous permettent de déployer WLS sur AKS de la manière la plus simple possible. WLS sur AKS offre une large sélection d’intégrations Azure. Pour obtenir plus d’informations, consultez la rubrique Quelles sont les solutions permettant d’exécuter Oracle WebLogic Server sur Azure Kubernetes Service ?

Les étapes suivantes vous montrent comment rechercher l’offre WLS sur AKS et remplir le volet Informations de base.

  1. Dans la barre de recherche située en haut du portail Azure, entrez weblogic. Dans les résultats de la recherche spontanée, au niveau de la section Place de marché, sélectionnez WebLogic Server sur AKS.

    Capture d’écran du portail Azure affichant WLS dans les résultats de la recherche.

    Vous pouvez également accéder directement à l'offre WebLogic Server sur AKS.

  2. Sur la page de l’offre, sélectionnez Créer.

  3. Dans le volet De base, assurez-vous que la valeur indiquée dans le champ Abonnement est la même que celle à laquelle vous vous êtes connecté dans Azure. Assurez-vous que vous disposez des rôles énumérés dans la section des conditions préalables.

    Capture d’écran du portail Azure affichant WebLogic Server sur AKS.

  4. Vous devez déployer l’offre dans un groupe de ressources vide. Dans le champ Groupe de ressources, sélectionnez Créer nouveau, puis indiquez une valeur pour le groupe de ressources. Étant donné que les groupes de ressources doivent être uniques au sein d’un abonnement, choisissez un nom unique. La solution la plus simple pour obtenir des noms uniques est d'utiliser une combinaison de vos initiales, de la date du jour et d'un identificateur, par exemple ejb0723wls.

  5. Sous Détails de l’instance, sélectionnez la région pour le déploiement. Pour obtenir la liste des régions Azure où AKS est disponible, consultez Disponibilité des régions AKS.

  6. Sous Informations d’identification pour WebLogic, laissez la valeur par défaut pour Nom d’utilisateur pour l’administrateur WebLogic.

  7. Renseignez wlsAksCluster2022 pour le mot de passe de l’administrateur WebLogic. Utilisez la même valeur pour les champs Confirmation et Mot de passe pour le chiffrement du modèle WebLogic.

  8. Faites défiler jusqu’au bas du volet Informations de base et repérez les liens utiles pour la documentation, le support de la communauté et la manière de signaler les problèmes.

  9. Cliquez sur Suivant.

Les étapes suivantes vous montrent comment démarrer le processus de déploiement.

  1. Faites défiler jusqu’à la section intitulée Fournir un compte Oracle à authentification unique (SSO). Renseignez vos informations d’identification SSO Oracle à partir des conditions préalables.

    Capture d’écran du portail Azure affichant le volet d’authentification unique configuré.

  2. Suivez les étapes de la boîte d'information dont le point de départ est Avant d'aller plus loin, vous devez accepter les conditions et restrictions standard d'Oracle.

  3. En fonction du fait que le compte Oracle SSO dispose ou non d'un droit d'assistance Oracle, sélectionnez l'option appropriée pour Sélectionnez le type WebLogic Server Images. Si le compte dispose d'un droit d'assistance, sélectionnez Patched WebLogic Server Images. A défaut, sélectionnez General WebLogic Server Images

  4. Laissez la valeur dans Sélectionner la combinaison souhaitée de WebLogic Server... à sa valeur par défaut. Vous disposez d'un large éventail de choix pour WLS, JDK et la version du système d'exploitation.

  5. Dans la section Application , près de Souhaitez-vous déployer une application ?, sélectionnez Non.

Les étapes suivantes permettent d'exposer la console d'administration WLS. De plus, l'application échantillon est exposée à l'Internet grand public grâce au module complémentaire d'entrée Application Gateway. Pour plus d'informations, consultez Qu'est-ce que le contrôleur d'entrée Application Gateway ?

Capture d’écran du portail Azure affichant la configuration la plus simple possible de l’équilibreur de charge sur la page Créer un serveur Oracle WebLogic sur Azure Kubernetes Service.

  1. Sélectionnez Suivant pour afficher le volet TLS/SSL.

  2. Sélectionnez Suivant pour afficher le volet Équilibrage de charge.

  3. Près de Options d'équilibrage de charge, sélectionnez Contrôleur d'entrée Application Gateway.

  4. Sous le Contrôleur d'entrée Application Gateway, vous constaterez que tous les champs sont préremplis avec les valeurs par défaut pour le réseau virtuel et le sous-réseau. Laissez les valeurs par défaut.

  5. Pour Créer une entrée pour la console d'administration, sélectionnez Oui.

    Capture d’écran du portail Azure affichant la configuration du contrôleur d’entrée Application Gateway sur la page Créer un serveur Oracle WebLogic sur Azure Kubernetes Service.

  6. Laissez les valeurs par défaut pour les autres champs.

  7. Sélectionnez Revoir + créer. Assurez-vous que la validation se déroule sans problème. En cas d'échec, corrigez les éventuels problèmes de validation, puis sélectionnez Réviser + Créer à nouveau.

  8. Sélectionnez Créer.

  9. Suivez la progression du déploiement sur la page Déploiement en cours.

En fonction des conditions du réseau et des autres activités dans la région sélectionnée, le déploiement peut prendre jusqu'à 50 minutes.

En attendant, vous pouvez suivre les étapes décrites dans la section Créer une base de données Azure SQL Database. Revenez à cette section lorsque vous avez terminé la création de la base de données.

Examiner la sortie du déploiement

Utilisez les étapes décrites dans cette section pour vérifier que le déploiement a réussi.

Si vous avez quitté la page Déploiement en cours, procédez comme suit pour y revenir. Si vous êtes toujours sur la page indiquant Votre déploiement est terminé, vous pouvez passer à l'étape 5 après la capture d'écran suivante.

  1. Dans tous les angles de la page du portail Microsoft Azure, sélectionnez le menu hamburger et choisissez Groupes de ressources.

  2. Dans la zone avec le texte Filtrer pour n’importe quel champ, entrez les premiers caractères du groupe de ressources que vous avez créé précédemment. Si vous avez suivi la convention recommandée, entrez vos initiales, puis sélectionnez le groupe de ressources approprié.

  3. Dans le volet de navigation de gauche, section Paramètres, sélectionnez Déploiements. Une liste triée des déploiements effectués dans ce groupe de ressources s’affiche, avec le plus récent en premier.

  4. Faites défiler la liste jusqu’à l’entrée la plus ancienne. Cette entrée correspond au déploiement que vous avez démarré dans la section précédente. Sélectionnez le déploiement le plus ancien, comme illustré dans la capture d’écran suivante.

    Capture d’écran du portail Azure affichant la liste des déploiements du groupe de ressources.

  5. Dans le volet de navigation, sélectionnez Sorties. La liste affiche les valeurs de sortie du déploiement. Des informations utiles sont incluses dans les sorties.

  6. La valeur adminConsoleExternalUrl est le lien public complet visible sur Internet vers la console d’administration WLS pour ce cluster AKS. Sélectionnez l’icône de copie en regard de la valeur du champ pour copier le lien dans le presse-papiers. Enregistrez cette valeur pour plus tard.

  7. La valeur clusterExternalUrl est le lien public complet visible sur Internet vers l’exemple d’application déployée dans WLS sur ce cluster AKS. Sélectionnez l’icône de copie en regard de la valeur du champ pour copier le lien dans le presse-papiers. Enregistrez cette valeur pour plus tard.

  8. La valeur shellCmdtoOutputWlsImageModelYaml est la chaîne base64 du modèle WDT construit dans l'image conteneur. Enregistrez cette valeur pour plus tard.

  9. La valeur shellCmdtoOutputWlsImageProperties est une chaîne base64 de propriétés de modèle WDT intégrées dans l'image conteneur. Enregistrez cette valeur pour plus tard.

  10. La valeur shellCmdtoConnectAks est la commande Azure CLI permettant de se connecter à ce cluster AKS spécifique. Cela vous permet d'utiliser kubectl pour administrer le cluster.

Les autres valeurs des sorties dépassent la portée de cet article, mais sont expliquées en détail dans le guide de l’utilisateur WebLogic sur AKS.

Créer une base de données Azure SQL

Pour créer une base de données unique Azure SQL Database à utiliser avec votre application, suivez les étapes de la section Démarrage rapide : Créer une base de données unique dans Azure SQL Database. Observez attentivement les différences suivantes :

  • A l’étape Informations de base, notez les valeurs des Groupe de ressources, le Nom de la base de données, <server-name>.database.windows.net, l’Identifiant de l’administrateur du serveur, et le Mot de passe. Cet article fait référence au groupe de ressources de base de données valeur en tant que <db-resource-group>.

  • À l’étape Mise en réseau, définissez Méthode de connectivité sur Point de terminaison public, définissez Autoriser les services et les ressources Azure à accéder à ce serveur sur Oui et Ajouter l’adresse IP actuelle du client sur Oui.

    Capture d’écran du portail Azure montrant l’onglet Mise en réseau de la page Créer une base de données SQL avec les paramètres de règles de connectivité et de pare-feu mis en surbrillance.

Remarque

Le niveau de calcul serverless que vous avez sélectionné pour cette base de données permet d'économiser de l'argent en mettant la base de données en sommeil pendant les périodes d'inactivité. L’exemple d’application échoue si la base de données est en veille au démarrage de l’application.

Pour forcer le réveil de la base de données, vous pouvez exécuter une requête à l’aide de l’éditeur de requête. Effectuez les étapes décrites dans Interroger la base de données. Voici un exemple de requête : SELECT * FROM COFFEE;.

  1. Créez un schéma pour l'application modèle. Cliquez sur Interroger la base de données pour ouvrir le volet de l'éditeur de requête. Entrez et exécutez la requête suivante :

    CREATE TABLE COFFEE (ID NUMERIC(19) NOT NULL, NAME VARCHAR(255) NULL, PRICE FLOAT(32) NULL, PRIMARY KEY (ID));
CREATE TABLE SEQUENCE (SEQ_NAME VARCHAR(50) NOT NULL, SEQ_COUNT NUMERIC(28) NULL, PRIMARY KEY (SEQ_NAME));
INSERT INTO SEQUENCE VALUES ('SEQ_GEN',0);

    Après une exécution réussie, vous verrez apparaître le message Requête réussie : lignes affectées : 0. Dans le cas contraire, dépannez et résolvez le problème avant de poursuivre.

La base de données, les tables, le cluster AKS et le cluster WLS sont créés. Si vous le souhaitez, vous pouvez explorer la console d'administration en ouvrant un navigateur et en vous rendant à l'adresse adminConsoleExternalUrl. Connectez-vous avec les valeurs que vous avez saisies lors du déploiement de WLS sur AKS.

Vous pouvez préparer AKS à héberger votre application WebLogic.

Configurer et déployer l’exemple d’application

L'offre fournit le cluster WLS via le modèle dans l'image. Actuellement, le cluster WLS n'a pas d'application déployée.

Cette section met à jour le cluster WLS en déployant un exemple d'application à l'aide de l'image auxiliaire.

Extraire l’application

Dans cette section, vous pouvez cloner l'exemple de code de ce guide. L'échantillon est sur GitHub dans le référentiel weblogic-on-azure dans le dossier javaee/weblogic-cafe/. Voici la structure des fichiers de l’application.

weblogic-cafe
├── pom.xml
└── src
    └── main
        ├── java
        │   └── cafe
        │       ├── model
        │       │   ├── CafeRepository.java
        │       │   └── entity
        │       │       └── Coffee.java
        │       └── web
        │           ├── rest
        │           │   └── CafeResource.java
        │           └── view
        │               └── Cafe.java
        ├── resources
        │   ├── META-INF
        │   │   └── persistence.xml
        │   └── cafe
        │       └── web
        │           ├── messages.properties
        │           └── messages_es.properties
        └── webapp
            ├── WEB-INF
            │   ├── beans.xml
            │   ├── faces-config.xml
            │   └── web.xml
            ├── index.xhtml
            └── resources
                └── components
                    └── inputPrice.xhtml

Utilisez les commandes suivantes pour cloner le référentiel :

cd <parent-directory-to-check-out-sample-code>
export BASE_DIR=$PWD
git clone --single-branch https://github.com/microsoft/weblogic-on-azure.git --branch 20240201 $BASE_DIR/weblogic-on-azure

Si un message vous signale que vous allez passer à l’état « detached HEAD », vous pouvez ignorer ce message sans risque. Cela signifie simplement que vous avez modifié une étiquette.

Utilisez la commande suivante pour générerjavaee/weblogic-cafe/ :

mvn clean package --file $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/pom.xml

Le package devrait être généré efficacement et localisé sur $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/target/weblogic-cafe.war. Si vous ne voyez pas le package, veuillez résoudre le problème avant de continuer.

Utilisez Docker pour créer une image auxiliaire

Les étapes décrites dans cette section vous montrent comment générer une image auxiliaire. Cette image comprend les éléments suivants :

  • le modèle dans les fichiers de Modèle d'image
  • Votre application.
  • le fichier d'archive du pilote JDBC
  • l'installation de WebLogic Deploy Tooling

Une image auxiliaire est une image conteneur Docker contenant votre application et votre configuration. L'opérateur Kubernetes WebLogic combine votre image auxiliaire avec le domain.spec.image du cluster AKS qui contient le serveur WebLogic, le JDK et le système d'exploitation. Pour plus d'informations sur les images auxiliaires, consultez les images auxiliaires dans la documentation Oracle.

Cette section nécessite un terminal Linux avec Azure CLI et kubectl installés.

Pour générer l'image, procédez comme suit :

  1. utilisez les commandes suivantes pour créer un répertoire dans lequel vous placerez les modèles et l'application :

    mkdir -p ${BASE_DIR}/mystaging/models
cd ${BASE_DIR}/mystaging/models

  2. Copiez la valeur shellCmdtoOutputWlsImageModelYaml que vous avez enregistrée à partir des sorties de déploiement, collez-la dans la fenêtre Bash et exécutez la commande. La commande doit être similaire à l’exemple suivant :

    echo -e IyBDb3B5cmlna...Cgo= | base64 -d > model.yaml

    Cette commande produit un fichier ${BASE_DIR}/mystaging/models/model.yaml dont le contenu est similaire à l'exemple suivant :

    # Copyright (c) 2020, 2021, Oracle and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

# Based on ./kubernetes/samples/scripts/create-weblogic-domain/model-in-image/model-images/model-in-image__WLS-v1/model.10.yaml
# in https://github.com/oracle/weblogic-kubernetes-operator.

domainInfo:
  AdminUserName: "@@SECRET:__weblogic-credentials__:username@@"
  AdminPassword: "@@SECRET:__weblogic-credentials__:password@@"
  ServerStartMode: "prod"

topology:
  Name: "@@ENV:CUSTOM_DOMAIN_NAME@@"
  ProductionModeEnabled: true
  AdminServerName: "admin-server"
  Cluster:
    "cluster-1":
      DynamicServers:
        ServerTemplate: "cluster-1-template"
        ServerNamePrefix: "@@ENV:MANAGED_SERVER_PREFIX@@"
        DynamicClusterSize: "@@PROP:CLUSTER_SIZE@@"
        MaxDynamicClusterSize: "@@PROP:CLUSTER_SIZE@@"
        MinDynamicClusterSize: "0"
        CalculatedListenPorts: false
  Server:
    "admin-server":
      ListenPort: 7001
  ServerTemplate:
    "cluster-1-template":
      Cluster: "cluster-1"
      ListenPort: 8001
  SecurityConfiguration:
    NodeManagerUsername: "@@SECRET:__weblogic-credentials__:username@@"
    NodeManagerPasswordEncrypted: "@@SECRET:__weblogic-credentials__:password@@"

resources:
  SelfTuning:
    MinThreadsConstraint:
      SampleMinThreads:
        Target: "cluster-1"
        Count: 1
    MaxThreadsConstraint:
      SampleMaxThreads:
        Target: "cluster-1"
        Count: 10
    WorkManager:
      SampleWM:
        Target: "cluster-1"
        MinThreadsConstraint: "SampleMinThreads"
        MaxThreadsConstraint: "SampleMaxThreads"

  3. De la même manière, copiez la valeur shellCmdtoOutputWlsImageProperties, collez-la dans la fenêtre Bash et exécutez la commande. La commande doit être similaire à l’exemple suivant :

    echo -e IyBDb3B5cml...pFPTUK | base64 -d > model.properties

    Cette commande produit un fichier ${BASE_DIR}/mystaging/models/model.properties dont le contenu est similaire à l'exemple suivant :

    # Copyright (c) 2021, Oracle Corporation and/or its affiliates.
# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

# Based on ./kubernetes/samples/scripts/create-weblogic-domain/model-in-image/model-images/model-in-image__WLS-v1/model.10.properties
# in https://github.com/oracle/weblogic-kubernetes-operator.

CLUSTER_SIZE=5

  4. Les étapes suivantes permettent de créer le fichier de modèle d'application.

    1. Utilisez les commandes suivantes pour copier weblogic-café.war et enregistrez-la dans wlsdeploy/applications :

      mkdir -p ${BASE_DIR}/mystaging/models/wlsdeploy/applications
cp $BASE_DIR/weblogic-on-azure/javaee/weblogic-cafe/target/weblogic-cafe.war ${BASE_DIR}/mystaging/models/wlsdeploy/applications/weblogic-cafe.war

    2. Utilisez les commandes suivantes pour créer le fichier de modèle d'application avec le contenu affiché. Enregistrez le fichier de modèle sur ${BASE_DIR}/mystaging/models/appmodel.yaml.

      cat <<EOF >appmodel.yaml
appDeployments:
  Application:
    weblogic-cafe:
      SourcePath: 'wlsdeploy/applications/weblogic-cafe.war'
      ModuleType: ear
      Target: 'cluster-1'
EOF

  5. Utilisez les commandes suivantes pour télécharger et installer le pilote JDBC de Microsoft SQL Server dans wlsdeploy/externalJDBCLibraries :

    export DRIVER_VERSION="10.2.1.jre8"
export MSSQL_DRIVER_URL="https://repo.maven.apache.org/maven2/com/microsoft/sqlserver/mssql-jdbc/${DRIVER_VERSION}/mssql-jdbc-${DRIVER_VERSION}.jar"

mkdir ${BASE_DIR}/mystaging/models/wlsdeploy/externalJDBCLibraries
curl -m 120 -fL ${MSSQL_DRIVER_URL} -o ${BASE_DIR}/mystaging/models/wlsdeploy/externalJDBCLibraries/mssql-jdbc-${DRIVER_VERSION}.jar

  6. Ensuite, utilisez les commandes suivantes pour créer le fichier de modèle de connexions aux bases de données avec le contenu affiché. Enregistrez le fichier de modèle dans ${BASE_DIR}/mystaging/models/dbmodel.yaml. Le modèle utilise des espaces réservés (secret sqlserver-secret) pour le nom d'utilisateur, le mot de passe et l'URL de la base de données. Vérifiez que les champs suivants sont correctement définis. Le modèle suivant nomme la ressource au moyen de jdbc/WebLogicCafeDB.

    Item Name Champ Valeur
    Nom JNDI resources.JDBCSystemResource.<resource-name>.JdbcResource.JDBCDataSourceParams.JNDIName jdbc/WebLogicCafeDB
    Nom du pilote resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.DriverName com.microsoft.sqlserver.jdbc.SQLServerDriver
    Url de la base de données resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.URL @@SECRET:sqlserver-secret:url@@
    Mot de passe de la base de données resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.PasswordEncrypted @@SECRET:sqlserver-secret:password@@
    Nom d’utilisateur de la base de données resources.JDBCSystemResource.<resource-name>.JDBCDriverParams.Properties.user.Value '@@SECRET:sqlserver-secret:user@@' 
    cat <<EOF >dbmodel.yaml
resources:
  JDBCSystemResource:
    jdbc/WebLogicCafeDB:
      Target: 'cluster-1'
      JdbcResource:
        JDBCDataSourceParams:
          JNDIName: [
            jdbc/WebLogicCafeDB
          ]
          GlobalTransactionsProtocol: None
        JDBCDriverParams:
          DriverName: com.microsoft.sqlserver.jdbc.SQLServerDriver
          URL: '@@SECRET:sqlserver-secret:url@@'
          PasswordEncrypted: '@@SECRET:sqlserver-secret:password@@'
          Properties:
            user:
              Value: '@@SECRET:sqlserver-secret:user@@'
        JDBCConnectionPoolParams:
          TestTableName: SQL SELECT 1
          TestConnectionsOnReserve: true
EOF

  7. Utilisez les commandes suivantes pour créer un fichier d'archivage d'application, puis supprimez le dossier wlsdeploy , dont vous n'avez plus besoin :

    cd ${BASE_DIR}/mystaging/models
zip -r archive.zip wlsdeploy

rm -f -r wlsdeploy

  8. Utilisez les commandes suivantes pour télécharger et installer WebLogic Deploy Tooling (WDT) dans le répertoire intermédiaire, et supprimez ses fichiers weblogic-deploy/bin/*.cmd , qui ne sont pas utilisés dans les environnements UNIX :

    cd ${BASE_DIR}/mystaging
curl -m 120 -fL https://github.com/oracle/weblogic-deploy-tooling/releases/latest/download/weblogic-deploy.zip -o weblogic-deploy.zip

unzip weblogic-deploy.zip -d .
rm ./weblogic-deploy/bin/*.cmd

  9. Utilisez la commande suivante pour supprimer le programme d'installation WDT :

    rm weblogic-deploy.zip

  10. Utilisez les commandes suivantes pour générer une image auxiliaire à l'aide de Docker :

    cd ${BASE_DIR}/mystaging
cat <<EOF >Dockerfile
FROM busybox
ARG AUXILIARY_IMAGE_PATH=/auxiliary
ARG USER=oracle
ARG USERID=1000
ARG GROUP=root
ENV AUXILIARY_IMAGE_PATH=\${AUXILIARY_IMAGE_PATH}
RUN adduser -D -u \${USERID} -G \$GROUP \$USER
# ARG expansion in COPY command's --chown is available in docker version 19.03.1+.
# For older docker versions, change the Dockerfile to use separate COPY and 'RUN chown' commands.
COPY --chown=\$USER:\$GROUP ./ \${AUXILIARY_IMAGE_PATH}/
USER \$USER
EOF

  11. Exécutez la commande docker buildx build en utilisant ${BASE_DIR}/mystaging/Dockerfile , comme indiqué dans l'exemple suivant :

    cd ${BASE_DIR}/mystaging
docker buildx build --platform linux/amd64 --build-arg AUXILIARY_IMAGE_PATH=/auxiliary --tag model-in-image:WLS-v1 .

    Lorsque vous générez convenablement l'image, le résultat correspond à l'exemple suivant :

    [+] Building 12.0s (8/8) FINISHED                                   docker:default
=> [internal] load build definition from Dockerfile                          0.8s
=> => transferring dockerfile: 473B                                          0.0s
=> [internal] load .dockerignore                                             1.1s
=> => transferring context: 2B                                               0.0s
=> [internal] load metadata for docker.io/library/busybox:latest             5.0s
=> [1/3] FROM docker.io/library/busybox@sha256:6d9ac9237a84afe1516540f40a0f  0.0s
=> [internal] load build context                                             0.3s
=> => transferring context: 21.89kB                                          0.0s
=> CACHED [2/3] RUN adduser -D -u 1000 -G root oracle                        0.0s
=> [3/3] COPY --chown=oracle:root ./ /auxiliary/                             1.5s
=> exporting to image                                                        1.3s
=> => exporting layers                                                       1.0s
=> => writing image sha256:2477d502a19dcc0e841630ea567f50d7084782499fe3032a  0.1s
=> => naming to docker.io/library/model-in-image:WLS-v1                      0.2s

  12. Si vous avez réussi à créer l’image, elle devrait désormais se trouver dans le référentiel Docker de votre ordinateur local. Vous pouvez vérifier la création de l'image à l'aide de la commande suivante :

    docker images model-in-image:WLS-v1

    Cette commande devrait générer des résultats similaires à ceux de l'exemple suivant :

    REPOSITORY       TAG       IMAGE ID       CREATED       SIZE
model-in-image   WLS-v1    76abc1afdcc6   2 hours ago   8.61MB

    Une fois l'image créée, elle doit contenir les exécutables WDT dans /auxiliary/weblogic-deploy, et les fichiers de modèles, de propriétés et d'archives WDT dans /auxiliary/models. Utilisez la commande suivante sur l'image Docker pour vérifier ce résultat :

    docker run -it --rm model-in-image:WLS-v1 find /auxiliary -maxdepth 2 -type f -print

    Cette commande devrait générer des résultats similaires à ceux de l'exemple suivant :

    /auxiliary/models/model.properties
/auxiliary/models/dbmodel.yaml
/auxiliary/models/model.yaml
/auxiliary/models/archive.zip
/auxiliary/models/appmodel.yaml
/auxiliary/Dockerfile
/auxiliary/weblogic-deploy/LICENSE.txt
/auxiliary/weblogic-deploy/VERSION.txt

  13. Suivez les étapes suivantes pour effectuer une transmission de type push de l'image auxiliaire vers Azure Container Registry :

    1. Ouvrez le portail Microsoft Azure et accédez au groupe de ressources que vous avez configuré dans la section Déployer WSL sur AKS.

    2. Sélectionnez la ressource de type Registre de conteneurs dans la liste des ressources.

    3. Passez la souris sur la valeur située près du serveur de connexion. Ensuite, sélectionnez l'icône de copie située à côté du texte.

    4. Enregistrez la valeur dans la variable d'environnement ACR_LOGIN_SERVER à l'aide de la commande suivante :

      export ACR_LOGIN_SERVER=<value-from-clipboard>

    5. Exécutez les commandes suivantes pour étiqueter et envoyer l'image. Assurez-vous que Docker est en cours d'exécution avant d'exécuter ces commandes.

      export ACR_NAME=$(echo ${ACR_LOGIN_SERVER} | cut -d '.' -f 1)
az acr login -n $ACR_NAME
docker tag model-in-image:WLS-v1 $ACR_LOGIN_SERVER/wlsaks-auxiliary-image:1.0
docker push $ACR_LOGIN_SERVER/wlsaks-auxiliary-image:1.0

    6. Vous pouvez exécuter az acr repository show pour tester si l'image a bien été transférée dans le référentiel distant, comme le montre l'exemple suivant :

      az acr repository show --name ${ACR_NAME} --image wlsaks-auxiliary-image:1.0

      Cette commande devrait générer des résultats similaires à ceux de l'exemple suivant :

      {
  "changeableAttributes": {
    "deleteEnabled": true,
    "listEnabled": true,
    "readEnabled": true,
    "writeEnabled": true
  },
  "createdTime": "2024-01-24T06:14:19.4546321Z",
  "digest": "sha256:a1befbefd0181a06c6fe00848e76f1743c1fecba2b42a975e9504ba2aaae51ea",
  "lastUpdateTime": "2024-01-24T06:14:19.4546321Z",
  "name": "1.0",
  "quarantineState": "Passed",
  "signed": false
}

Appliquer l'image auxiliaire

Dans les étapes précédentes, vous avez créé l'image auxiliaire, y compris les modèles et WDT. Avant d'appliquer l'image auxiliaire au cluster WLS, procédez comme suit pour créer le secret de l'URL de la source de données, du nom d'utilisateur et du mot de passe. Le secret est utilisé comme partie de l'espace réservé dans le fichier dbmodel.yaml.

  1. Connectez-vous au cluster AKS en copiant la valeur shellCmdtoConnectAks que vous avez enregistrée précédemment, en la collant dans la fenêtre Bash, puis en exécutant la commande. La commande doit être similaire à l’exemple suivant :

    az account set --subscription <subscription>; 
az aks get-credentials \
    --resource-group <resource-group> \
    --name <name>

    Vous devez obtenir une sortie similaire à la suivante. Dans le cas contraire, dépannez et résolvez le problème avant de poursuivre.

    Merged "<name>" as current context in /Users/<username>/.kube/config

  2. Procédez comme suit pour obtenir les valeurs des variables affichées dans le tableau suivant. Vous utiliserez ces valeurs ultérieurement pour créer le secret de la connexion à la source de données.

    Variable Description Exemple
    DB_CONNECTION_STRING Chaîne de connexion du serveur SQL. jdbc:sqlserver://sqlserverforwlsaks.database.windows.net:1433;database=wlsaksquickstart0125
    DB_USER Nom d'utilisateur à connecter au serveur SQL. welogic@sqlserverforwlsaks
    DB_PASSWORD Mot de passe à connecter au serveur SQL. Secret123456

    1. Visitez la ressource de base de données SQL dans le portail Microsoft Azure.

    2. Dans le volet de navigation, sous Paramètres, sélectionnez Chaînes de connexion.

    3. Sélectionnez l'onglet JDBC.

    4. Sélectionnez l'icône de copie pour copier la chaîne de connexion dans le presse-papiers.

    5. Pour DB_CONNECTION_STRING, utilisez toute la chaîne de connexion. Toutefois, remplacez l'espace {your_password_here} par le mot de passe de votre base de données.

    6. Pour DB_USER, utilisez la partie de la chaîne de connexion allant de azureuser jusqu'à ;password={your_password_here} (non compris).

    7. Pour DB_PASSWORD, utilisez la valeur que vous avez entrée lors de la création de la base de données.

  3. Utilisez les commandes suivantes pour créer le secret Kubernetes. Cet article utilise le nom de secret sqlserver-secret pour le secret de la connexion à la source de données. Si vous utilisez un autre nom, vérifiez que la valeur est identique à celle de dbmodel.yaml.

    Dans les commandes suivantes, veillez à définir correctement les variables DB_CONNECTION_STRING, DB_USER et DB_PASSWORD en remplaçant les exemples dans l'espace réservé par les valeurs décrites dans les étapes précédentes. Veillez à placer la valeur des variables DB_ entre des guillemets uniques afin d'éviter que l'interpréteur de commandes n'interfère avec les valeurs.

    export DB_CONNECTION_STRING='<example-jdbc:sqlserver://sqlserverforwlsaks.database.windows.net:1433;database=wlsaksquickstart0125>'
export DB_USER='<example-welogic@sqlserverforwlsaks>'
export DB_PASSWORD='<example-Secret123456>'
export WLS_DOMAIN_NS=sample-domain1-ns
export WLS_DOMAIN_UID=sample-domain1
export SECRET_NAME=sqlserver-secret

kubectl -n ${WLS_DOMAIN_NS} create secret generic \
    ${SECRET_NAME} \
    --from-literal=password="${DB_PASSWORD}" \
    --from-literal=url="${DB_CONNECTION_STRING}" \
    --from-literal=user="${DB_USER}"

kubectl -n ${WLS_DOMAIN_NS} label secret \
    ${SECRET_NAME} \
    weblogic.domainUID=${WLS_DOMAIN_UID}

    Vous devez voir apparaître la sortie suivante avant de continuer. Dans le cas contraire, dépannez et résolvez le problème avant de poursuivre.

    secret/sqlserver-secret created
secret/sqlserver-secret labeled

  4. Appliquez l'image auxiliaire en effectuant une mise à jour corrective de la définition de ressource personnalisée du domaine (CRD) à l'aide de la commande kubectl patch.

    L'image auxiliaire est définie dans spec.configuration.model.auxiliaryImages, comme illustré dans l'exemple suivant. Pour plus d'informations, consultez les images auxiliaires.

    spec:
  clusters:
  - name: sample-domain1-cluster-1
  configuration:
    model:
      auxiliaryImages:
      - image: wlsaksacrafvzeyyswhxek.azurecr.io/wlsaks-auxiliary-image:1.0
        imagePullPolicy: IfNotPresent
        sourceModelHome: /auxiliary/models
        sourceWDTInstallHome: /auxiliary/weblogic-deploy

    Utilisez les commandes suivantes pour augmenter la valeur restartVersion et utilisez kubectl patch pour appliquer l'image auxiliaire au domaine CRD en utilisant la définition illustrée :

    export VERSION=$(kubectl -n ${WLS_DOMAIN_NS} get domain ${WLS_DOMAIN_UID} -o=jsonpath='{.spec.restartVersion}' | tr -d "\"")
export VERSION=$((VERSION+1))

cat <<EOF >patch-file.json
[
  {
    "op": "replace",
    "path": "/spec/restartVersion",
    "value": "${VERSION}"
  },
  {
    "op": "add",
    "path": "/spec/configuration/model/auxiliaryImages",
    "value": [{"image": "$ACR_LOGIN_SERVER/wlsaks-auxiliary-image:1.0", "imagePullPolicy": "IfNotPresent", "sourceModelHome": "/auxiliary/models", "sourceWDTInstallHome": "/auxiliary/weblogic-deploy"}]
  },
  {
    "op": "add",
    "path": "/spec/configuration/secrets",
    "value": ["${SECRET_NAME}"]
  }
]
EOF

kubectl -n ${WLS_DOMAIN_NS} patch domain ${WLS_DOMAIN_UID} \
    --type=json \
    --patch-file patch-file.json

kubectl get pod -n ${WLS_DOMAIN_NS} -w

  5. Patientez jusqu'à ce que le serveur d'administration et les serveurs gérés affichent les valeurs du bloc de sortie suivant avant de poursuivre :

    NAME                             READY   STATUS    RESTARTS   AGE
sample-domain1-admin-server      1/1     Running   0          20m
sample-domain1-managed-server1   1/1     Running   0          19m
sample-domain1-managed-server2   1/1     Running   0          18m

    Le système peut mettre 5 à 10 minutes pour atteindre cet état. La liste suivante fournit une vue d'ensemble de ce qui se passe pendant que vous attendez :

    • Vous devez au préalable voir sample-domain1-introspector en cours d'exécution. Ce logiciel recherche les modifications apportées à la ressource personnalisée du domaine afin de pouvoir prendre les mesures nécessaires sur le cluster Kubernetes.
    • Lorsque des changements sont détectés, l'introspecteur de domaine arrête et démarre de nouveaux les pod pour déployer les changements.
    • Ensuite, vous verrez le pod sample-domain1-admin-server s'arrêter et redémarrer.
    • Puis, vous verrez les deux serveurs gérés s'arrêter et redémarrer.
    • Vous ne pourrez poursuivre l'opération que lorsque les trois pod auront atteint l'état 1/1 Running.

Vérifier la fonctionnalité du déploiement

Les étapes suivantes permettent de vérifier la fonctionnalité du déploiement en affichant la console d'administration WLS et l'application d'exemple :

  1. Collez la valeur adminConsoleExternalUrl dans la barre d'adresse d'un navigateur web connecté à Internet. Vous verrez l'écran familier de connexion à la console d'administration WLS.

  2. Connectez-vous avec le nom d'utilisateur weblogic et le mot de passe que vous avez saisi lors du déploiement de WLS à partir du portail Microsoft Azure. Rappelez-vous que cette valeur est wlsAksCluster2022.

  3. Dans la boîte Structure du domaine, sélectionnez Services.

  4. Sous Services, sélectionnez Sources de données.

  5. Dans le panneau Résumé des sources de données JDBC, sélectionnez Monitoring. Votre écran devrait s'apparenter à l'exemple suivant. Vous découvrez que l’état de la source de données est en cours d’exécution sur des serveurs gérés.

    Capture d’écran de l’état de la source de données.

  6. Dans la boîte Structure du domaine, sélectionnez Déploiements.

  7. Dans le tableau Déploiements, il doit y avoir une ligne. Le nom doit avoir la même valeur que dans votre fichier Applicationappmodel.yaml. Sélectionnez le nom.

  8. Dans le volet Paramètres , sélectionnez l'onglet Test.

  9. Sélectionnez weblogic-cafe.

  10. Dans le volet Paramètres de weblogic-cafe, sélectionnez l'onglet Test.

  11. Développez l'icône + située près de weblogic-café. Votre écran devrait s'apparenter à l'exemple suivant. En particulier, vous devriez voir des valeurs similaires à http://sample-domain1-managed-server1:8001/weblogic-cafe/index.xhtml dans la colonne Point de test.

    Capture d’écran des points de test weblogic-cafe.

    Remarque

    Les liens hypertextes dans la colonne Point de test ne sont pas sélectionnables, car nous n'avons pas configuré la console d'administration avec l'URL externe sur laquelle elle s'exécute. Cet article montre la console d’administration WLS uniquement à titre de démonstration. N’utilisez pas la console d’administration WLS pour toute modification de configuration durable lorsque vous exécutez WLS sur AKS. La conception native Cloud de WLS sur AKS nécessite que toute configuration durable soit représentée dans les images Docker initiales ou appliquée au cluster AKS en cours d’exécution à l’aide de techniques CI/CD telles que la mise à jour du modèle, comme décrit dans la documentation Oracle.

  12. Comprendre la valeur context-path de l'échantillon d'application que vous avez déployé. Si vous avez déployé l’exemple d’application recommandé, context-path est weblogic-cafe.

  13. Construisez une URL entièrement qualifiée pour l'application échantillon en ajoutant le context-path à la valeur clusterExternalUrl. Si vous avez déployé l'application échantillon recommandée, l'URL pleinement qualifiée devrait ressembler à http://wlsgw202401-wls-aks-domain1.eastus.cloudapp.azure.com/weblogic-cafe/ .

  14. Collez l’URL complète dans un navigateur Web connecté à Internet. Si vous avez déployé l'application échantillon recommandée, vous devriez obtenir des résultats similaires à la capture d'écran suivante :

    Capture d’écran de l’application web de test.

Nettoyer les ressources

Pour éviter des frais Azure, vous devez nettoyer les ressources non nécessaires. Lorsque vous n’avez plus besoin du cluster, utilisez la commande az group delete. La commande suivante supprime le groupe de ressources, le service conteneurs, le registre de conteneurs et toutes les ressources associées :

az group delete --name <resource-group-name> --yes --no-wait
az group delete --name <db-resource-group-name> --yes --no-wait

Étapes suivantes

Pour en savoir plus sur l’exécution de WLS sur AKS ou sur des machines virtuelles, suivez ces liens :

WLS sur AKS

Migrer les applications WebLogic Server vers Azure Kubernetes Service

WLS sur des machines virtuelles