Déploiement de code personnalisé dans OpenShift | HCL Digital Experience

Cette section décrit le déploiement de code personnalisé sur HCL Digital Experience dans OpenShift.

Pourquoi et quand exécuter cette tâche

Suivez ces étapes pour déployer du code personnalisé dans OpenShift.

Outre les avantages de la migration d'HCL Digital Experience vers un environnement conteneurisé et orchestré, il y a également des changements au niveau du déploiement et de la personnalisation. Les conteneurs étant de courte durée, les modifications apportées pendant l'exécution du conteneur sont transitoires. C'est pour cela qu'un volume persistant est requis pour conserver les paramètres de configuration HCL Digital Experience. L'arborescence de répertoires de profil du serveur, le point de montage par défaut et obligatoire pour la persistance, stocke actuellement ces informations, par exemple, /opt/HCL/wp_profile.

L'approche recommandée pour déployer des applications personnalisées sur HCL Digital Experience s'exécutant dans la plateforme de conteneur OpenShift consiste à utiliser un pipeline Continuous Integration and Continuous Delivery (CI/CD) connecté à un référentiel de code source contenant un script de pipeline. Dans notre cas, nous utilisons Jenkins et GitHub. Un exemple Jenkinsfile et BuildConfig.yaml sont fournis.

Dans un environnement OpenShift, vous pouvez déployer une instance Jenkins avec l'une des deux (2) commandes OpenShift Client suivantes.

oc new-app jenkins-ephemeral

oc new-app jenkins-persistent

Comme les commandes le suggèrent, l'instance Jenkins peut être persistante ou transitoire. Pour que l'instance soit persistante, un volume persistant est nécessaire.

Configurez les outils du serveur Jenkins le cas échéant pour répondre à vos exigences en matière de génération de code personnalisé. Accédez à Gérer Jenkins > Configuration globale des outils et ajoutez les outils nécessaires pour générer votre application. Dans notre cas, nous avons configuré Ant et JDK 8.
Configurez les informations d'identification du serveur Jenkins selon vos besoins pour accéder à votre référentiel de code source. La connexion via une clé SSH pour le référentiel d'applications et OpenShift est recommandée.
```
ssh-keygen -C "openshift-source-builder/repo@github" -f repo-at-github -N ''
```
Cela va générer un fichier de clés publiques repo-at-github et un fichier de clés publiques repo-at-github.pub.
Copiez le contenu de la clé publique dans votre presse-papiers.
```
clip < ~/.ssh/repo-at-github.pub
```
Accédez à votre référentiel GitHub > Paramètres > Clés de déploiement > Ajouter une clé de déploiement. Donnez un titre à la clé, collez le contenu du presse-papiers dans la zone de texte de la clé et cliquez sur Ajouter une clé.
Copiez le contenu de la clé privée dans votre presse-papiers.
```
clip < ~/.ssh/repo-at-github
```

Ajoutez la clé privée au serveur Jenkins en tant que secret OpenShift.

oc create secret generic repo-at-github --from-file=ssh-privatekey=~/.ssh/repo-at-github

Associez le secret au générateur OpenShift.
```
oc secrets link builder repo-at-github
```

Créez une configuration de génération OpenShift pour générer le code d'application personnalisé stocké dans GitHub à l'aide de l'exemple de fichier YAML fourni personnalisé pour votre environnement.

oc create -f customized-sample-build-config.yaml

kind: BuildConfig
apiVersion: build.openshift.io/v1
metadata:
  name: <name of your application pipeline>
  namespace: <namespace-in-openshift>
spec:
  source:
    git:
      uri: "git@github.com:<my custom code directory>/<my custom repository>.git"
  strategy:
    jenkinsPipelineStrategy:
      jenkinsfilePath: jenkinsfile
  triggers:
    - type: GitHub
      github:
        secret: <myCustomAppSecret>

Associez le secret du référentiel GitHub à la configuration de génération OpenShift.
```
oc set build-secret --source bc/custom-editor-app-pipeline repo-at-github
```
Pour permettre à OpenShift de compiler et de déployer l'application personnalisée avec chaque validation de code source dans GitHub, configurez un Webhook dans le référentiel GitHub pour la configuration de génération OpenShift.
Accédez à votre référentiel GitHub > Paramètres > Webhooks > Ajouter un Webhook. Pour trouver la valeur de l'URL de charge utile Webhook, utilisez la commande de description du client OpenShift pour la configuration de configuration :
```
oc describe bc/<name of your application pipeline>
```
Par exemple, votre URL de charge utile Webhook peut ressembler à ceci :
```
https://api.hcl-dxdev.hcl-dx-dev.net:6443/apis/build.openshift.io/v1/namespaces/<namespace-in-openshift>/buildconfigs/<nameOfYourApplicationPipeline>/webhooks/<myCustomAppSecretFromTheSampleBuildConfigFile>/github
```
Définissez le type de contenu du Webhook sur application/json. Si votre environnement n'utilise pas un certificat correctement signé, choisissez de désactiver SSL.
Installez et configurez les plug-ins Jenkins requis pour votre environnement de génération d'application.
Accédez à Gérer Jenkins > Gérer les plug-ins. Dans l'onglet Disponible, installez les plug-ins suivants le cas échéant, ainsi que d'autres requis en fonction de vos besoins.
- ```
WebSphere-Deployer Plugin
```
- ```
Copy Artifact Plugin
```
- ```
OpenShift Client Jenkins Plugin (if not already installed)
```
Configurez le plug-in WebSphere-Deployer pour vous connecter à WebSphere Integrated Solutions Console. Redémarrez le serveur Jenkins.
```
https://<jenkins-in-openshift-url>/restart
```
Remarque : Si, dans un environnement OpenShift, un certificat SSL approuvé est requis pour le plug-in WebSphere-Deployer. Le référentiel source et le serveur Jenkins nécessitent un accès réseau à l'itinéraire WebSphere Integrated Solution Console.
Créez le travail de déploiement Jenkins pour votre application. Utilisez le plug-in Copy Artifact pour fournir la sortie de génération d'application au niveau du travail de déploiement.
Remarque : Il est nécessaire de configurer le travail de déploiement pour l'application dans l'interface graphique Jenkins, car le plug-in WebSphere-Deployer n'est pas exécutable à partir de la ligne de commande et ne peut donc pas être scripté.
Accédez à votre OpenShift ProjectName > Nouvel élément, indiquez un nom pour le travail de déploiement d'application, sélectionnez Projet au style libre et cliquez sur OK.
Dans l'onglet Général de la page de configuration du travail de déploiement, cochez la case Limiter les endroits où le projet peut être exécuté et entrez maître dans la zone de texte Expression d'étiquette.
Remarque : Le plug-in WebSphere-Deployer prend uniquement en charge le déploiement à partir d'un maître Jenkins.
Faites défiler vers le bas jusqu'à la section Etape de génération de la page de configuration, dans la liste déroulante Ajouter une étape de construction, puis choisissez Copier les artefacts d'un autre projet. Pour le nom du projet, entrez le nom du projet de génération d'application. Le nom du projet de génération d'application par défaut sera <namespace-in-openshift>-<name of your application pipeline>.
Dans la liste déroulante Quelle génération, sélectionnez Génération en amont qui a déclenché ce travail. Dans la zone de texte Artefacts à copier, entrez les artefacts requis pour votre déploiement. Saisissez tous les paramètres supplémentaires pertinents pour votre environnement.
Faites défiler la page jusqu'à la section Actions de post-génération de la page de configuration, dans la liste déroulante Ajouter une action de post-génération, puis choisissez Déployer sur IBM WebSphere Application Server. Entrez les informations WebSphere requises pour votre environnement. Cochez la case Se connecter à l'aide de Sécurité globale et entrez le nom d'utilisateur et le mot de passe de l'administrateur WebSphere.
Remarque : Les informations d'identification de l'administrateur WebSphere sont stockées en texte brut dans les fichiers config.xml de travail sur le maître Jenkins.
Cochez la case Approuver le certificat SSL. Cliquez sur le bouton Avancé... et entrez les valeurs Magasin de clés et Magasin de clés de confiance.

Vérifiez que les boutons Tester la connexion et/ou Afficher les cibles disponibles affichent des retours réussis. Entrez toutes les options de déploiement supplémentaires pertinentes pour votre application et cliquez sur Enregistrer.

Remarque : Le pipeline peut être lancé depuis la page Configurations de la génération de la console de la plateforme OpenShift, la commande oc start-build <build-config-name> ou via une validation dans le référentiel GitHub.

Le pipeline copiera l'artefact d'application vers une instance HCL Digital Experience dans OpenShift. Le répertoire dans lequel l'artefact est copié doit déjà exister et disposer des droits appropriés.

Exemple de fichier Jenkins

pipeline{
   agent any
   environment {
      appName           = 'CustomHTMLEditor'
      earFileName       = 'CustomHTMLEditor.ear'
      antHome           = tool 'JenkinsAnt'
      //Name of the pod to which the application binaries will be copied
      dx_instance_name  = 'dx-deployment-0'
      //Path location within HCL Digital Experience to where to the applciation binaries will be copied
      app_binary_path   = '/opt/HCL/wp_profile/customApps/'
   }
   options {
      //Value needs to match the name of the downstream application deploy job created in the Jenkins console.
      copyArtifactPermission('deploy-custom-editor-app') 
   }   
   stages {
      stage('Log Entry') { 
         steps {
            script {
               openshift.withCluster() {
                  openshift.withProject() {
                     echo "Building: ${appName} in project: ${openshift.project()}."
                  }
               }
            }
         }
      }      
      stage('Checkout') { 
         steps {
            git 'http://github.com:<my custom code directory>/<my custom repository>.git'
         }
      }
      stage('Build') {
         steps {
               sh "'${antHome}/bin/ant' clean makezips"
         }
      }
      stage('Archive') {
         steps {
            archiveArtifacts 'build/dist/*.ear'
         }
      }      
      stage('Deliver') {
         steps {
            script {
               openshift.withCluster() {
                  openshift.withProject() {
                  def result = openshift.raw ( 'cp', '${WORKSPACE}/build/dist/${earFileName} ${dx_instance_name}:${app_binary_path}')
                  echo "Delivery Status:  ${result.out}"
                  }
               }
            }
         }
      }        
      stage('Deploy'){
         steps {
            //Value needs to match the name of the downstream application deploy job created in the Jenkins console.
            build 'deploy-custom-editor-app'
            }
      }
      stage('Log Exit') { 
         steps {
            script {
               openshift.withCluster() {
                  openshift.withProject() {
                     echo "Completed build, delivery and deployment of ${appName} in project: ${openshift.project()}."
                  }
               }
            }
         }
      }        
   }  
}