Configuration de l'interface de ligne de commande

Dans cette étape, vous allez configurer l'interface de ligne de commande oc pour qu'elle pointe vers le cluster que vous venez de créer. Le CLI de Red Hat OpenShift on IBM Cloud Container Platform expose des commandes pour gérer vos applications, ainsi que des outils de niveau inférieur pour interagir avec chaque composant de votre système. L'interface de ligne de commande est disponible en utilisant la commande oc.

1. Lorsque le cluster est prêt, cliquez sur OpenShift web console pour ouvrir la console.
2. Sur la console Web, dans le menu déroulant situé dans l'angle supérieur droit de la page, cliquez sur Copy Login Command, puis sur le lien Display Token.
3. Copiez le texte qui se trouve sous Se connecter avec ce jeton.
4. Une fois connecté à l'aide de la commande oc login, exécutez la commande ci-dessous pour voir tous les espaces de noms de votre cluster.

   oc get ns
   

Créer un projet

Un espace de nom Kubernetes fournit un mécanisme permettant de parcourir les ressources figurant dans un cluster. Dans Red Hat OpenShift on IBM Cloud, un projet est un espace de nom Kubernetes avec des annotations supplémentaires.

1. Définissez une variable d'environnement nommée MYPROJECT et définissez le nom de l'application en remplaçant <your-initials> par vos propres initiales :

   export MYPROJECT=<your-initials>-openshiftapp
   

2. Créez un nouveau projet.

   oc new-project $MYPROJECT
   

   Après avoir créé un projet à l'aide de la commande ci-dessus, vous basculez automatiquement vers ce projet et toutes les commandes qui suivent s'exécutent dans le contexte de ce projet. Si vous devez changer de projet ou y revenir ultérieurement, utilisez la commande oc project $MYPROJECT.

Déployer une application

La commande oc new-app vous permet de créer des applications à partir d'un code source dans un référenciel Git local ou distant.

1. Créez une application en utilisant la stratégie de génération docker pour générer une image de conteneur à partir d'un fichier Dockerfile dans le référentiel. Vous définissez le nom de l'application sur le nom du projet pour la simplicité.

   oc new-app https://github.com/IBM-Cloud/openshift-node-app --name=$MYPROJECT --strategy=docker --as-deployment-config
   

   S'il existe un fichier Jenkins dans le répertoire racine ou le répertoire de contexte spécifié du référentiel source lors de la création d'une application, Red Hat OpenShift on IBM Cloud génère une stratégie de génération de type pipeline. Sinon, il génère une stratégie de génération source. Vous pouvez toujours remplacer la stratégie de génération en définissant l'indicateur --strategy.

2. Pour vérifier la création de l'image du conteneur builder et son transfert vers le site interne Red Hat OpenShift on IBM Cloud Container Registry (OCR), exécutez la commande ci-dessous.

   oc logs -f buildconfig/$MYPROJECT
   

   Votre cluster est configuré avec le registre d'images Red Hat OpenShift on IBM Cloud Container Registry interne pour qu'Red Hat OpenShift on IBM Cloud puisse générer, déployer et gérer automatiquement le cycle de vie de vos applications depuis le cluster.

3. Attendez que la compilation soit réussie et que l'image soit poussée. Vous pouvez vérifier le statut du déploiement et du service en exécutant la commande ci-dessous.

   oc status
   

Accéder à l'application par le biais du domaine IBM fourni

Pour accéder à l'application, vous devez créer un itinéraire. Une route permet d'exposer votre service au monde entier.

1. Créez une route en exécutant la commande ci-dessous dans un terminal.

   oc expose service/$MYPROJECT
   

2. Vous pouvez accéder à l'application via un domaine fourni par IBM. Exécutez la commande ci-dessous pour obtenir l' URL.

   oc get route/$MYPROJECT
   

3. Copiez la valeur du nom d'hôte sous la valeur HOST/PORT et collez l'adresse URL dans un navigateur pour voir votre application en action à l'adresse http://<hostname>. Veillez à utiliser http dans l' URL.

4. Définir une variable d'environnement pointant vers le nom d'hôte.

   export HOST=<hostname>
   

Sécurisation de la route du domaine fourni par IBM par défaut

1. Pour créer une route HTTPS sécurisée, chiffrée avec le certificat par défaut pour Red Hat OpenShift on IBM Cloud, vous pouvez utiliser la commande create route.

   oc create route edge $MYPROJECT-https --service=$MYPROJECT --port=3000
   

2. Pour obtenir l'URL de l'hôte HTTPS (HTTPS HOST URL), exécutez la commande oc get routes. Copiez et collez l'URL avec HTTPS (https://<HOST>) en regard de la route $MYPROJECT-https dans un navigateur. Cette fois, vous pouvez utiliser https dans l' URL.

Mise à l'échelle manuelle

1. Vous pouvez effectuer une mise à l'échelle manuelle de vos pods avec la commande oc scale. Cette commande définit une nouvelle taille pour une configuration de déploiement ou un contrôleur de réplication.

   oc scale dc/$MYPROJECT --replicas=2
   

2. Vous pouvez utiliser un nouveau pod en cours de mise à disposition en exécutant la commande oc get pods.
3. Réexécutez l'étape Surveillance pour afficher les métriques mises à jour.

Mise à l'échelle automatique

Vous pouvez utiliser un programme de mise à l'échelle automatique de pod horizontale (HPA) pour indiquer la manière dont Red Hat OpenShift on IBM Cloud doit augmenter ou diminuer automatiquement l'échelle d'une configuration de déploiement (dc) ou d'un contrôleur de réplication (rc), en fonction des métriques collectées des pods qui appartiennent à cette dc ou ce rc.

1. Pour pouvoir configurer la mise à l'échelle automatique de vos pods, vous devez au préalable définir des limites de ressources sur les pods exécutés dans le cluster. Ces limites vous permettent de choisir les quantités d'UC et de mémoire minimales et maximales utilisées pour un pod. Vous pouvez définir les limites et demandes sur un conteneur à l'aide de la commande oc set resources.

   oc set resources dc/$MYPROJECT --limits=cpu=250m,memory=512Mi --requests=cpu=100m,memory=256Mi
   

   Pour les vérifier, exécutez oc describe dc/$MYPROJECT, puis recherchez Limits et Requests.
2. Pour créer un programme de mise à l'échelle automatique, vous devez exécuter la commande oc autoscale avec les limites inférieure (min) et supérieure (max) du nombre de pods pouvant être définis par le programme de mise à l'échelle automatique et la quantité moyenne d'UC cible utilisée (représentée en pourcentage de la quantité d'UC demandée) sur tous les pods. Pour les tests, définissez --cpu-percent à 5 %.

   oc autoscale dc/$MYPROJECT \
    --min=1 \
    --max=5 \
    --cpu-percent=5
   

3. Réexécutez l'étape Surveillance pour générer la charge sur l'application.
4. Vous pouvez voir les nouveaux pods mis à disposition en exécutant la commande oc get pods --watch ou en examinant l'application dans la console Web.
5. Retirez le programme de mise à l'échelle automatique :

   oc delete hpa/$MYPROJECT
   

Cloner un exemple d'application

Dans cette section, vous allez cloner un référentiel GitHub qui est fourni avec un fichier modèle et un script shell pour générer un fichier yaml à partir des variables d'environnement précédemment créées. Le fichier généré est utilisé pour construire une image de conteneur, pousser l'image vers le registre de conteneurs privé et déployer une nouvelle application.

1. Dans un terminal, exécutez la commande ci-dessous pour cloner le dépôt GitHub sur votre machine :

   git clone https://github.com/IBM-Cloud/openshift-node-app
   

2. Accédez au répertoire de l'application :

   cd openshift-node-app
   

Mise à jour de la section BuildConfig et insertion de l'image du générateur dans Container Registry

Dans cette étape, vous exécutez un script pour mettre à jour les sections du fichier openshift.template.yaml et générer un nouveau fichier yaml pointant vers votre espace de nom Container Registry.

1. Exécutez le script bash ci-dessous pour mettre à jour les marques de réservation dans le fichier openshift.template.yaml et générer le fichier openshift_private_registry.yaml.

   ./generate_yaml.sh use_private_registry
   

2. Exécutez la commande export à partir de la sortie pour définir la variable d'environnement existante MYPROJECT avec le nom de la nouvelle application. Exécutez la commande echo $MYPROJECT pour afficher le nom de la nouvelle application.

3. Vous pouvez éventuellement vérifier le fichier openshift_private_registry.yaml généré pour voir si toutes les marques de réservation ont été mises à jour avec les variables d'environnement respectives. Vous trouverez ci-dessous trois endroits où effectuer une vérification rapide. Vous pouvez passer à la section suivante.

4. Facultatif Localisez l'objet ImageStream dont l'attribut name est défini sur votre projet ($MYPROJECT) et vérifiez si les espaces réservés $MYREGISTRY,$MYNAMESPACE, et $MYPROJECT sous dockerImageRepository définition de spec sont mis à jour

   -
   apiVersion: image.openshift.io/v1
   kind: ImageStream
   metadata:
     annotations:
       openshift.io/generated-by: OpenShiftNewApp
     creationTimestamp: null
     labels:
       app: $MYPROJECT
       app.kubernetes.io/component: $MYPROJECT
       app.kubernetes.io/instance: $MYPROJECT
     name: $MYPROJECT
   spec:
     dockerImageRepository: $MYREGISTRY/$MYNAMESPACE/$MYPROJECT
     lookupPolicy:
       local: false
   status:
       dockerImageRepository: ""
   

   Un flux d'images et ses balises associées fournissent une abstraction pour référencer les images de conteneur depuis Red Hat OpenShift on IBM Cloud Container Platform

5. Facultatif Vérifiez que la spécification spec sous la section BuildConfig pour la sortie a été définie sur le type DockerImage et les marques de réservation sous name mises à jour.

   spec:
     nodeSelector: null
     output:
       to:
         kind: DockerImage
         name: $MYREGISTRY/$MYNAMESPACE/$MYPROJECT:latest
       pushSecret:
         name: push-secret
   

   Une génération est le processus de transformation des paramètres d'entrée pour obtenir un objet. Le plus souvent, ce processus est utilisé pour transformer des paramètres d'entrée ou du code source en image exécutable. Un objet BuildConfig est la définition de l'ensemble du processus de génération.

6. Facultatif Recherchez containers, vérifiez image et name

   containers:
   - image: $MYREGISTRY/$MYNAMESPACE/$MYPROJECT:latest
     name: $MYPROJECT
   

7. Si vous l'avez mis à jour, sauvegardez le fichier YAML.

Déploiement de l'application à l'aide d'IBM Cloud Container Registry

Dans cette section, vous allez déployer l'application dans le cluster à l'aide du fichier openshift_private_registry.yaml généré. Une fois le déploiement terminé, vous accéderez à l'application en créant une route.

1. Créer une nouvelle application OpenShift avec une buildconfig(bc), une deploymentconfig(dc), un service(svc), un imagestream(is) en utilisant le yaml mis à jour.

   oc apply -f openshift_private_registry.yaml
   

2. Pour vérifier la création de l'image du conteneur builder et son transfert sur le site Container Registry, exécutez la commande ci-dessous.

   oc logs -f bc/$PRIVREG
   

   Dans les journaux, vous devriez voir le message suivant si l'image du conteneur est poussée vers le registre de conteneurs privés.

   Pushing image us.icr.io/mods15/vmac-openshift-app-registry:latest ...
   Getting image source signatures
   Copying blob sha256:9d038e1c7afbe92c29313557c02110e8fb796818ebb78441c68929381103a94b
   Copying blob sha256:61c671f49591a059c9b6728a9f84c16f5b00126470112ee9c9f9e01dbbfcc3ea
   Copying blob sha256:e2787650308235c87eff7d2b88c3ab217e84b74a3fa9696103bd46bb99068c7a
   Copying blob sha256:dcef409117430ed9906a59ad0a3ea0752061fbf8a9e544f4edd77667a25d85ae
   Copying blob sha256:a1f889dd610c6510c7fc091a51c247463f3cc9a7c67bdc397c9632168808f7d2
   Copying blob sha256:bd278801acd18ada10f43b732113a6fffc163011862ea6cde729f8dc59e64222
   Copying blob sha256:2d6c03ed5d15be86cdef7d9c0c9fea40a3f6b89662bca59680d037074f52bb38
   Copying blob sha256:fa2ef7f80d6fc9543f6eb472846931ed1cec2b5f776d1b67bcb1b9942e1a947e
   Copying blob sha256:ff5a4e4d3690ccc931900b63714d326cc53a58e644f8d0a4f06bf8c62f11c5c7
   Copying config sha256:01aa1ebb7be74529867106100c4e699ca2ae87f8242460771527f772e6a3d174
   Writing manifest to image destination
   Storing signatures
   Successfully pushed us.icr.io/mods15/vmac-openshift-app-registry@sha256:6847b889397704b9fb8c3122c84b505c3dc5f99a0669fb69f534d3504eec385d
   Push successful
   

3. Vous pouvez vérifier l'état du déploiement et du service.

   oc status
   

4. Importer manuellement le dernier flux d'images pour s'assurer que le déploiement a lieu dès que possible.

   oc import-image $PRIVREG
   

   Vous pouvez également utiliser la commande si le déploiement prend plus de temps, voir ce lien pour plus d'informations.

5. Exposez le service pour créer une nouvelle route.

   oc expose service/$PRIVREG
   

6. Vous pouvez accéder à l'application par le biais du domaine fourni par IBM. Exécutez la commande ci-dessous pour obtenir l' URL.

   oc get route/$PRIVREG
   

7. Copiez la valeur du nom d'hôte sous la valeur HOST/PORT et collez l'adresse URL dans un navigateur pour voir votre application en action à l'adresse http://<hostname>. Veillez à utiliser http dans l' URL.

   Vous devez voir la même application exposée sur une autre route et déployée à l'aide de l'image de conteneur stockée dans un registre de conteneur privé.

Création d'un jeton de déploiement Git

Dans cette section, vous allez créer un jeton de déploiement Git pour autoriser l'accès en lecture seule à votre référentiel.

Pour générer un jeton de déploiement :

1. Dans le panneau de navigation de la page Git repo, cliquez sur Settings > Repository.
2. Cliquez sur Expand en regard de Deploy Tokens.
   1. Dans la zone Nom, entrez foropenshift, puis sélectionnez read_repository sous Portées. Enfin, cliquez sur Créer un jeton de déploiement.
   2. Sauvegardez le nom d'utilisateur (username) et le mot de passe (password) générés pour référence ultérieure.
3. Dans le panneau de navigation, cliquez sur Aperçu du projet, puis sur Cloner et copiez Cloner avec HTTPS URL. Sauvegardez l'adresse URL pour référence ultérieure.
4. Définissez les variables d'environnement pour le nom d'utilisateur, le mot de passe et l'URL du référentiel Git privé à utiliser ultérieurement avec le fichier YAML dans le tutoriel

   export GIT_TOKEN_USERNAME=<PRIVATE_GIT_DEPLOY_TOKEN_USERNAME>
   export GIT_TOKEN_PASSWORD=<PRIVATE_GIT_DEPLOY_TOKEN_PASSWORD>
   export REPO_URL=<PRIVATE_GIT_REPO_URL>
   

Déploiement d'une nouvelle application à l'aide du registre privé et du code du référentiel privé

1. Exécutez le script bash ci-dessous pour mettre à jour les marques de réservation dans le fichier openshift.template.yaml et générer le fichier openshift_private_repository.yaml.

   ./generate_yaml.sh use_private_repository
   

2. Exécutez la commande export à partir de la sortie pour définir la variable d'environnement existante MYPROJECT avec le nom du nouveau projet.

3. En plus des marques de réservation du registre de conteneur privé, le script remplace également l'URL REPO_URL sous la section spec BuildConfig par les variables d'environnement que vous avez définies à l'étape ci-dessus,

    source:
      git:
        uri: $REPO_URL
      type: Git
   

4. Créer une nouvelle application openshift avec un buildconfig(bc), deploymentconfig(dc), service(svc), imagestream(is) en utilisant le yaml mis à jour

   oc apply -f openshift_private_repository.yaml
   

5. Vous pouvez consulter les journaux du générateur.

   oc logs -f bc/$PRIVREPO
   

6. Vous pouvez vérifier l'état du déploiement et du service en utilisant.

   oc status
   

7. Importer manuellement le dernier flux d'images pour s'assurer que le déploiement a lieu dès que possible.

   oc import-image $PRIVREPO
   

8. Exposez le service pour créer une nouvelle route.

   oc expose service/$PRIVREPO
   

9. Vous pouvez accéder à l'application par le biais du domaine fourni par IBM. Exécutez la commande ci-dessous pour obtenir l' URL.

   oc get route/$PRIVREPO
   

10. Copiez la valeur du nom d'hôte sous la valeur HOST/PORT et collez l'adresse URL dans un navigateur pour voir votre application en action à l'adresse http://<hostname>. Veillez à utiliser http dans l' URL.

    Une nouvelle application est déployée à l'aide du code du référentiel Git privé et de l'image de conteneur de l'espace de nom du registre privé.

Mise à jour de l'application et redéploiement

Dans cette étape, vous allez automatiser le processus de génération et de déploiement. Chaque fois que vous mettez à jour l'application et que vous envoyez les modifications au référentiel privé, une nouvelle génération génère une nouvelle version de l'image de conteneur. Cette image est ensuite déployée automatiquement.

1. Vous allez créer un nouveau déclencheur de webhook GitLab. Les déclencheurs de webhook vous permettent de lancer une nouvelle génération en envoyant une demande au noeud final d'API Red Hat OpenShift on IBM Cloud Container Platform. Vous pouvez définir ces déclencheurs avec GitHub, GitLab, Bitbucket ou des déclencheurs de webhook génériques.

   oc set triggers bc $PRIVREPO --from-gitlab
   

2. Pour ajouter un webhook dans le référentiel GitLab, vous avez besoin d'une URL et d'une valeur confidentielle (secret).

   • Pour l'URL du webhook GitLab,

     oc describe bc/$PRIVREPO | grep -A 1 "GitLab"
     

   • Pour le secret qui doit être transmis à l'URL du webhook,

     oc get bc/$PRIVREPO -o yaml | grep -A 3 "\- gitlab"
     

   • **Remplacez ** <secret>dans l'URL GitLab du webhook la valeur secrète sous gitlab dans la sortie de la commande ci-dessus.

3. Ouvrez votre repo git privé dans un navigateur en utilisant le lien Git repo HTTPS puis cliquez sur Settings et cliquez sur Webhooks.

4. Collez l'URL, sélectionnez Push events comme Trigger et cliquez sur Add webhook. Le message Webhook was created doit s'afficher.

5. Mettez à jour ImagePolicy dans l'élément ImageStream pour interroger Container Registry à un intervalle planifié afin de synchroniser les métadonnées de balise et d'image. Cette opération mettra à jour la définition de tags.

   oc tag $MYREGISTRY/$MYNAMESPACE/${PRIVREPO}:latest ${PRIVREPO}:latest --scheduled=true
   

6. Ouvrez le dépôt cloné dans un IDE pour mettre à jour la balise h1 du fichier local public/index.html et la remplacer par Congratulations! <insert your name>.

7. Sauvegarder et pousser le code dans le référentiel.

    git add public/index.html
   

    git commit -m "Updated with my name"
   

    git push -u origin master
   

8. Vous pouvez vérifier la progression de la génération et du déploiement avec la commande oc status. Une fois le déploiement terminé, actualisez l'adresse de l'hôte (HOST) de la route pour voir l'application Web mise à jour.

   Parfois, le déploiement peut prendre jusqu'à 15 minutes pour importer le dernier flux d'images. Vous pouvez attendre ou effectuer une importation manuelle à l'aide de la commande oc import-image $PRIVREPO. Consultez ce lien pour plus d'informations.

Avec HTTP

1. Créez une route exposant le service à un nom d'hôte en remplaçant <HOSTNAME> par votre nom d'hôte (par exemple, www.example.com ou openshiftapp.example.com), afin que les clients externes puissent l'atteindre par leur nom.

   oc expose svc/$PRIVREPO --hostname=<HOSTNAME> --name=$PRIVREPO-domain --port=3000
   

2. Accédez à votre application à l'adresse http://<HOSTNAME>/

Avec HTTPS

1. Pour créer une route HTTPS sécurisée, vous pouvez utiliser votre propre certificat et vos fichiers de clés à partir d'une autorité de certification telle que Let's Encrypt ou une commande via Secrets Manager. Transmettez-les à l'aide de la commande create route

   oc create route edge $PRIVREPO-httpsca --service=$PRIVREPO --cert=example.pem --key=example.key --hostname=<www.HOSTNAME> --port=3000
   

   Ici, vous avez utilisé une terminaison Edge. Pour en savoir plus sur les autres routes sécurisées et types de terminaison possibles, telles que passe-système et rechiffrement, exécutez la commande oc create route --help