Révolutionner le déploiement de l’interface utilisateur de Chatbot OpenAI avec DevSecOps / Blogs / Perficient

À l’ère contemporaine des plateformes numériques, capter et maintenir l’intérêt des utilisateurs constitue un élément essentiel déterminant le triomphe de tout logiciel. Qu’il s’agisse de sites Web ou d’applications mobiles, offrir aux utilisateurs des rencontres engageantes et personnalisées revêt la plus haute importance. Dans ce projet, nous visons à implémenter DevSecOps pour le déploiement d’une interface utilisateur OpenAI Chatbot, en tirant parti de Kubernetes (EKS) pour l’orchestration des conteneurs, de Jenkins pour l’intégration continue/déploiement continu (CI/CD) et de Docker pour la conteneurisation.

Qu’est-ce que ChatBOT ?

Un ChatBOT est une interface conversationnelle basée sur l’intelligence artificielle qui s’appuie sur de vastes ensembles de données de conversations humaines à des fins de formation. Grâce à des méthodes sophistiquées de traitement du langage naturel, il comprend les demandes des utilisateurs et fournit des réponses semblables à une conversation humaine. En émulant les nuances du langage humain, les ChatBOT améliorent l’interaction des utilisateurs, offrant une assistance personnalisée et augmentant les niveaux d’engagement.

Qu’est-ce qui fait des ChatBOT un choix convaincant ?

La justification du choix des ChatBOT réside dans leur capacité à révolutionner l’interaction des utilisateurs et les processus d’assistance. En exploitant l’intelligence artificielle et le traitement du langage naturel, les ChatBOT offrent des réponses instantanées et personnalisées aux demandes des utilisateurs. Cela améliore non seulement l’engagement des utilisateurs, mais rationalise également le service client, réduit les temps de réponse et allège le fardeau des opérateurs humains. De plus, les ChatBOT peuvent fonctionner 24 heures sur 24, répondant aux besoins des utilisateurs à tout moment, garantissant ainsi une expérience d’interaction transparente et efficace. Dans l’ensemble, l’adoption de la technologie ChatBOT représente une évolution stratégique vers l’amélioration de la satisfaction des utilisateurs, de l’efficacité opérationnelle et de la productivité globale de l’entreprise.

Les principales fonctionnalités d’un ChatBOT incluent :

1. Traitement du langage naturel (NLP) : Les ChatBOT exploitent les techniques de PNL pour comprendre et interpréter les requêtes des utilisateurs exprimées en langage naturel, leur permettant ainsi de fournir des réponses pertinentes.
2. Interface conversationnelle : Les ChatBOT utilisent une interface conversationnelle pour engager avec les utilisateurs des conversations de type humain, facilitant ainsi une communication et une interaction fluides.
3. Personnalisation: Les ChatBOT peuvent adapter les réponses et les recommandations en fonction des préférences de l’utilisateur, des interactions passées et des informations contextuelles, offrant ainsi une expérience personnalisée.
4. Prise en charge multicanal : Les ChatBOT sont conçus pour fonctionner sur divers canaux de communication, notamment les sites Web, les plateformes de messagerie, les applications mobiles et les assistants vocaux, garantissant ainsi l’accessibilité aux utilisateurs.
5. Capacités d’intégration : Les ChatBOT peuvent s’intégrer aux systèmes, bases de données et services tiers existants, leur permettant d’accéder et de récupérer des informations pertinentes pour aider efficacement les utilisateurs.
6. Apprentissage continu : Les ChatBOT utilisent des algorithmes d’apprentissage automatique pour apprendre en permanence des interactions des utilisateurs et améliorer leur compréhension et leurs performances au fil du temps, renforçant ainsi leur efficacité.
7. Évolutivité : Les ChatBOT sont évolutifs et capables de gérer un grand volume d’interactions utilisateur simultanées sans compromettre les performances, garantissant ainsi fiabilité et efficacité.
8. Analyses et informations : Les ChatBOT fournissent des analyses et des informations sur les interactions des utilisateurs, les mesures d’engagement, les questions fréquemment posées et les domaines à améliorer, permettant aux organisations d’optimiser leur stratégie ChatBOT.
9. Sécurité et conformité : Les ChatBOT donnent la priorité à la sécurité et à la conformité en mettant en œuvre des mesures telles que le cryptage, les contrôles d’accès et le respect des réglementations sur la protection des données pour protéger les informations des utilisateurs et garantir la confidentialité.
10. Personnalisation et extensibilité : Les ChatBOT offrent des options de personnalisation et une extensibilité via des API et des cadres de développement, permettant aux organisations de les adapter à des cas d’utilisation spécifiques et d’intégrer des fonctionnalités supplémentaires si nécessaire.

Grâce à l’adoption de méthodologies DevSecOps et à l’exploitation de technologies de pointe telles que Kubernetes, Docker et Jenkins, nous garantissons le déploiement sûr, évolutif et efficace de ChatBOT. Cette initiative vise à augmenter considérablement les niveaux d’engagement et de satisfaction des utilisateurs.

J’adresse nos sincères remerciements à McKay Wrigley, le visionnaire derrière ce projet. Ses contributions inestimables au domaine du DevSecOps ont rendu réalisables des projets tels que le projet ChatBOT UI.

Flux de travail des pipelines

Commençons par construire nos pipelines pour le déploiement de l’application OpenAI Chatbot. Je vais créer deux pipelines dans Jenkins,

1. Création d’une infrastructure à l’aide de Terraform sur le cloud AWS.
2. Déploiement de l’application Chatbot sur le nœud du cluster EKS.

Prérequis: Serveur Jenkins configuré avec Docker, Trivy, Sonarqube, Terraform, AWS CLI, Kubectl.

Une fois, nous avons réussi à établir et configurer un serveur Jenkins, équipé de tous les outils nécessaires pour créer un pipeline DevSecOps à déployer en suivant mes précédentes Blog. Nous pouvons commencer à créer notre pipeline DevSecOps pour le déploiement de chatbot OpenAI.

La première chose à faire est de configurer backend distant Terraform.

1. Créez un compartiment S3 avec n’importe quel nom.
2. Créez une table DynamoDB avec le nom « Lock-Files » et la clé de partition comme « LockID ».
3. Mettez à jour le nom du compartiment S3 et le nom de la table DynamoDB dans le fichier backend.tf, qui se trouve dans le dossier EKS-TF sous Dépôt Github.

Créer un pipeline Jenkins

Connectons-nous à notre console du serveur Jenkins une fois que vous avez rempli les conditions préalables. Cliquez sur « Nouvel élément » et donnez-lui un nom, sélectionnez pipeline puis ok.

Je souhaite créer ce pipeline avec des paramètres de construction à appliquer et à détruire lors de la construction uniquement. Vous devez ajouter ce travail interne comme l’image ci-dessous.

Ajoutons un pipeline, la définition sera Pipeline Script.

pipeline{
    agent any
    stages {
        stage('Checkout from Git'){
            steps{
                git branch: 'main', url: 'https://github.com/sunsunny-hub/Chatbot-UIv2.git'
            }
        }
        stage('Terraform version'){
             steps{
                 sh 'terraform --version'
             }
        }
        stage('Terraform init'){
             steps{
                 dir('EKS-TF') {
                      sh 'terraform init'
                   }      
             }
        }
        stage('Terraform validate'){
             steps{
                 dir('EKS-TF') {
                      sh 'terraform validate'
                   }      
             }
        }
        stage('Terraform plan'){
             steps{
                 dir('EKS-TF') {
                      sh 'terraform plan'
                   }      
             }
        }
        stage('Terraform apply/destroy'){
             steps{
                 dir('EKS-TF') {
                      sh 'terraform ${action} --auto-approve'
                   }      
             }
        }
    }
}

Appliquons, enregistrons et construisons avec des paramètres et sélectionnons l’action à appliquer.

Vue de la scène, la mise à disposition prendra au maximum 10 minutes.

Sortie océan bleu

Vérifiez dans votre console AWS si elle a créé le cluster EKS ou non.

L’instance Ec2 est créée pour le groupe Node.

Créons maintenant un nouveau pipeline pour le clonage du chatbot. Dans ce pipeline, l’application chatbot sera déployée sur le conteneur Docker après un déploiement réussi, et la même image Docker sera déployée sur le cluster eks provisionné ci-dessus.

Sous la section Pipeline, fournissez les détails ci-dessous.

Definition: Pipeline script from SCM
SCM : Git
Repo URL : Your GitHub Repo 
Credentials: Created GitHub Credentials
Branch: Main
Path: Your Jenkinsfile path in GitHub repo.

Appliquez et enregistrez et cliquez sur Construire. Une fois l’exécution réussie, vous pouvez voir toutes les étapes en vert.

Sonar-Console :

Vous pouvez voir que le rapport a été généré et que l’état indique qu’il a échoué. Vous pouvez l’ignorer dès maintenant pour ce POC, mais dans le projet en temps réel, tous ces profils/portes de qualité doivent être franchis.

Vérification des dépendances :

Analyse de fichiers Trivy :

Numérisation d’images triviales :

DockerHub :

Accédez maintenant à l’application sur le port 3000 de l’adresse IP publique de l’instance Jenkins Server Ec2.

Remarque : Assurez-vous que le port 3000 est autorisé dans le groupe de sécurité du serveur Jenkins.

Cliquez sur openai.com (de couleur bleue)

Cela vous redirigera vers la page de connexion ChatGPT où vous pourrez saisir votre e-mail et votre mot de passe. Dans la section Clés API, cliquez sur « Créer une nouvelle clé secrète ».

Donnez un nom et copiez-le. Revenez à l’interface utilisateur du chatbot que nous avons déployée et en bas de la page, vous verrez la clé API OpenAI, donnez la clé générée et cliquez sur enregistrer (MARQUE DE DROITE).

L’interface utilisateur ressemble à :

Maintenant, vous pouvez poser des questions et le tester.

Déploiement sur EKS

Nous devons maintenant ajouter les informations d’identification pour le cluster eks, qui seront utilisées pour déployer l’application sur le nœud du cluster eks. Pour cela, connectez-vous au serveur Jenkins. Donnez cette commande pour ajouter du contexte.

aws eks update-kubeconfig --name <clustername> --region <region>

Il générera un fichier de configuration Kubernetes. Accédez au répertoire où se trouve le fichier de configuration et copiez son contenu.

cd .kube
cat config

Enregistrez la configuration copiée dans votre explorateur de fichiers local à votre emplacement préféré et nommez-la sous forme de fichier texte.

Ensuite, dans la console Jenkins, ajoutez ce fichier à la section Informations d’identification avec l’ID « k8s » en tant que fichier secret.

Enfin, intégrez cette étape de déploiement dans votre fichier Jenkins.

stage('Deploy to kubernetes'){
            steps{
                withAWS(credentials: 'aws-key', region: 'ap-south-1'){
                script{
                    withKubeConfig(caCertificate: '', clusterName: '', contextName: '', credentialsId: 'k8s', namespace: '', restrictKubeConfigAccess: false, serverUrl: '') {
                       sh 'kubectl apply -f k8s/chatbot-ui.yaml'
                  }
                }
            }
        }
      }

Maintenant, réexécutez le pipeline Jenkins.

En cas de succès :

Dans les Jenkins, donnez cette commande

kubectl get all
kubectl get svc #use anyone

Cela créera un Classic Load Balancer sur la console AWS.

Copiez le nom DNS et collez-le dans votre navigateur pour l’utiliser.

Remarque : effectuez le même processus pour obtenir la clé API OpenAI et ajoutez la clé pour obtenir la sortie sur l’interface utilisateur de Chatbot.

Le fichier Jenkins complet :

pipeline{
    agent any
    tools{
        jdk 'jdk17'
        nodejs 'node19'
    }
    environment {
        SCANNER_HOME=tool 'sonar-scanner'
    }
    stages {
        stage('Checkout from Git'){
            steps{
                git branch: 'main', url: 'https://github.com/sunsunny-hub/Chatbot-UIv2.git'
            }
        }
        stage('Install Dependencies') {
            steps {
                sh "npm install"
            }
        }
        stage("Sonarqube Analysis "){
            steps{
                withSonarQubeEnv('sonar-server') {
                    sh ''' $SCANNER_HOME/bin/sonar-scanner -Dsonar.projectName=Chatbot \
                    -Dsonar.projectKey=Chatbot '''
                }
            }
        }
        stage("quality gate"){
           steps {
                script {
                    waitForQualityGate abortPipeline: false, credentialsId: 'Sonar-token' 
                }
            } 
        }
        stage('OWASP FS SCAN') {
            steps {
                dependencyCheck additionalArguments: '--scan ./ --disableYarnAudit --disableNodeAudit', odcInstallation: 'DP-Check'
                dependencyCheckPublisher pattern: '**/dependency-check-report.xml'
            }
        }
        stage('TRIVY FS SCAN') {
            steps {
                sh "trivy fs . > trivyfs.json"
            }
        }
        stage("Docker Build & Push"){
            steps{
                script{
                   withDockerRegistry(credentialsId: 'docker', toolName: 'docker'){   
                       sh "docker build -t chatbot ."
                       sh "docker tag chatbot surajsingh16/chatbot:latest "
                       sh "docker push surajsingh16/chatbot:latest "
                    }
                }
            }
        }
        stage("TRIVY"){
            steps{
                sh "trivy image surajsingh16/chatbot:latest > trivy.json" 
            }
        }
        stage ("Remove container") {
            steps{
                sh "docker stop chatbot | true"
                sh "docker rm chatbot | true"
             }
        }
        stage('Deploy to container'){
            steps{
                sh 'docker run -d --name chatbot -p 3000:3000 surajsingh16/chatbot:latest'
            }
        }
        stage('Deploy to kubernetes'){
            steps{
                withAWS(credentials: 'aws-key', region: 'ap-south-1'){
                script{
                    withKubeConfig(caCertificate: '', clusterName: '', contextName: '', credentialsId: 'k8s', namespace: '', restrictKubeConfigAccess: false, serverUrl: '') {
                       sh 'kubectl apply -f k8s/chatbot-ui.yaml'
                  }
                }
            }
        }
        }
    }
    }

J’espère que vous avez déployé avec succès l’application OpenAI Chatbot UI. Vous pouvez également supprimer les ressources en utilisant le même pipeline Terraform en sélectionnant l’action « détruire » et en exécutant le pipeline.