Documentation Oracle Cloud Infrastructure

Kubernetes : déploiement d'une application Node Express

Dans ce tutoriel, vous utilisez un compte Oracle Cloud Infrastructure pour configurer un cluster Kubernetes. Ensuite, vous déployez une application Node Express vers le cluster.

Les principales tâches expliquent comment :

  • configurer un cluster Kubernetes sur OCI,
  • configurer l'interface de ligne de commande OCI pour accéder au cluster,
  • créer une application Node Express et une image Docker,
  • propager l'image vers OCIR,
  • déployer l'application Docker Node.js vers le cluster,
  • vous connecter à l'application à partir d'Internet.
Diagramme des composants nécessaires à l'exécution d'une application NodeJS Express sur Oracle Cloud Infrastructure Kubernetes Engine

Pour plus d'informations, voir :

Avant de commencer

Pour suivre ce tutoriel, vous avez besoin des éléments suivants :

Exigences
  • Pour Container Registry, Kubernetes et les équilibreurs de charge :
  • Pour la création d'applications et d'images Docker :
    • Un des environnements locaux suivants :
    • Les applications suivantes sur l'environnement local :
      • JDK 11 et JAVA_HOME dans .bashrc.
      • Python 3.6.8+ et programme d'installation de pip pour Python 3
      • Client Kubernetes 1.11.9+
      • Apache Maven 3.0+
      • Docker 19.0.3+
      • Git 1.8+
      • Node.js 10+
Remarque

Si vous ne souhaitez pas configurer les applications requises sur l'environnement local, vous pouvez utiliser Oracle Cloud Infrastructure Cloud Shell à la place. L'avantage de Cloud Shell est que tous les outils nécessaires à la gestion de votre application sont déjà installés et prêts à être utilisés. Suivez les étapes 1 et 2 de la rubrique :

Kubernetes avec Cloud Shell : déploiement d'une application Spring Boot

Obtention des applications pour Linux sur le niveau gratuit OCI

Si vous souhaitez utiliser une instance de calcul Linux de niveau gratuit OCI pour gérer votre déploiement, vous trouverez les informations permettant d'installer le logiciel requis dans les sections suivantes.

Installation d'une instance Linux
  • Installez une machine virtuelle Linux avec une forme de calcul Toujours gratuit sur Oracle Cloud Infrastructure. Vous avez besoin d'un ordinateur prenant en charge ssh pour vous connecter à l'instance Linux.
    • Installation d'une machine virtuelle Oracle Linux
      • Suivez les sections 2 et 3.
      • Si vous disposez d'un compte payant, pour la section 2, choisissez vos options de calcul en fonction de vos offres.
      • Pour vous connecter à l'instance, dans la section 4, suivez les étapes 1 à 5.
      • Ignorez les instructions Apache.
    • Installation d'une machine virtuelle Ubuntu
      • Suivez les sections 2 et 3.
      • Si vous disposez d'un compte payant, pour la section 2, choisissez des options de calcul en fonction de vos offres.
      • Pour vous connecter à l'instance, dans la section 4, suivez les étapes 1 à 5.
      • Ignorez les instructions Apache.
      • Pour mettre à jour les paramètres du pare-feu, dans la section 4, effectuez l'étape 8.
Installation de Node.js

Installez Node.js sur votre système.

Exécution des commandes d'installation

Pour installer Node.js et NPM, exécutez les commandes suivantes :

  1. Oracle Linux : 
    sudo yum update

    Configurez le référentiel Yum pour Node.js. Installez ensuite le package nodejs.

    sudo yum install -y oracle-nodejs-release-el7
sudo yum install -y nodejs
  2. Ubuntu : 
    sudo apt update

    Installez les packages nodejs et npm.

    sudo apt install -y nodejs
sudo apt install -y npm
  3. Vérifiez l'installation. 
    node -v
npm -v
Configuration du pare-feu (facultatif)

Si vous souhaitez tester votre application Node avec un navigateur, rendez le port 3000 disponible sur votre instance Linux.

  • Oracle Linux 
    sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-service=https --permanent
sudo firewall-cmd --reload
  • Ubuntu Linux 
    sudo iptables -I INPUT 6 -m state --state NEW -p tcp --dport 3000 -j ACCEPT
sudo netfilter-persistent save
Création d'une règle entrante pour le réseau cloud virtuel (facultatif)

Suivez ces étapes pour sélectionner le sous-réseau public du réseau cloud virtuel et ajouter la règle entrante.

  1. Ouvrez le menu de navigation et cliquez sur Fonctions de réseau, puis sur Réseaux cloud virtuels.
  2. Sélectionnez le réseau cloud virtuel que vous avez créé avec l'instance de calcul.
  3. Lorsque le nouveau réseau cloud virtuel est affiché, cliquez sur le lien du sous-réseau <nom-du-sous-réseau>.

    Les informations sur le sous-réseau public sont affichées avec les listes de sécurité en bas de la page. Un lien vers la liste de sécurité par défaut du réseau cloud virtuel s'affiche.

  4. Cliquez sur le lien Liste de sécurité par défaut.

    Les règles entrantes par défaut du réseau cloud virtuel sont affichées.

  5. Cliquez sur Ajouter des règles entrantes.

    La boîte de dialogue Ajouter des règles entrantes apparaît.

  6. Renseignez la règle entrante avec les informations suivantes.

    Renseignez la règle entrante comme suit :

    • Sans conservation de statut : option cochée
    • Type de source : CIDR
    • CIDR source : 0.0.0.0/0
    • Protocole IP : TCP
    • Plage de ports source : (à laisser vide)
    • Plage de ports de destination : 3000
    • Description : Autoriser les connexions HTTP
  7. Cliquez sur Ajouter une règle entrante.

    Les connexions HTTP sont désormais autorisées. Le réseau cloud virtuel est configuré pour Node Express.

Vous avez créé une règle entrante qui rend votre instance disponible à partir d'Internet.

Installation de Python 3 et de Pip 3
  1. Vérifiez l'installation en cours.
    python3 --version
  2. Pour Python 3, exécutez les commandes suivantes :
    • Oracle Linux : 
      sudo yum update
      sudo yum install -y python3
    • Ubuntu :
      sudo apt update
      sudo apt install -y python3
  3. Vérifiez l'installation de pip pour Python3.
    pip3 -V

    Exemple de sortie si pip pour Python3 est installé :

    pip <version> from xxx/lib/python3.x/site-packages/pip (python 3.x)
  4. Pour installer pip pour Python 3, exécutez les commandes suivantes :
    • Oracle Linux : 
      sudo yum update
      sudo yum install -y python3-pip
    • Ubuntu :
      sudo apt update
      sudo apt install -y python3-pip
  5. Vérifiez l'installation de pip pour Python 3.
    pip3 -V
Installation du client Kubernetes
  1. Vérifiez l'installation en cours : 
    kubectl version --client
    Si vous disposez de Kubernetes, la version est <version-majeure>.<version-mineure>. Par exemple, pour la version 1.20, vous obtenez ce qui suit :
    version.Info{Major:"1", Minor:"20"...
  2. Pour installer le client kubectl, reportez-vous aux liens suivants :
  3. Vérifiez l'installation. 
    kubectl version --client
Installation de Docker
  1. Vérifiez l'installation en cours : 
    docker -v
  2. Oracle Linux

    Pour installer Docker sur Oracle Linux, exécutez les commandes suivantes.

    sudo yum install docker-engine
    sudo systemctl start docker
    sudo systemctl enable docker

    Remarque : la dernière commande permet à Docker de démarrer lors des redémarrages.

  3. Ubuntu Linux

    Pour installer Docker sur Ubuntu Linux, reportez-vous à ce lien permettant d'obtenir Docker.

  4. Vérifiez l'installation. 
    docker -v

1. Préparation

Préparez votre environnement pour créer et déployer l'application.

Vérification des limites de service
  1. Connectez-vous à la console Oracle Cloud Infrastructure.
  2. Ouvrez le menu de navigation et cliquez sur Gouvernance et administration. Sous Gouvernance, cliquez sur Limites, quotas et utilisation.
  3. Recherchez la limite du service Regions :
    • Filtrez sur les options suivantes :
      • Service : Regions
      • Portée : Location
      • Ressource : nombre d'abonnements à des régions
      • Compartiment : <tenancy-name> (racine)
    • Recherchez la limite de service :
      • Nom de la limite : subscribed-region-count
      • Limite de service : 2 au minimum
  4. Recherchez le nombre de coeurs Compute disponibles pour la forme VM.Standard.E3.Flex :
    • Filtrez sur les options suivantes :
      • Service : Compute
      • Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
      • Ressource : Coeurs pour les instances Standard.E3.Flex et BM.Standard.E3.128
      • Compartiment : <tenancy-name> (racine)
    • Recherchez le nombre de coeurs disponibles :
      • Nom de la limite : standard-e3-core-ad-count
      • Disponible : 1 au minimum.
    • Répétez l'opération pour Portée : <deuxième-domaine-de-disponibilité> et <troisième-domaine-de-disponibilité>. Chaque région doit disposer d'au moins un coeur pour cette forme.
  5. Déterminez si vous disposez de 50 Go de volume de blocs :
    • Filtrez sur les options suivantes :
      • Service : Block Volume.
      • Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
      • Ressource : Taille de volume (Go)
      • Compartiment : <tenancy-name> (racine)
    • Recherchez le stockage de volume de blocs disponible :
      • Nom de la limite : total-storage-gb
      • Disponible : 50
    • Répétez l'opération pour Portée : <deuxième-domaine-de-disponibilité> et <troisième-domaine-de-disponibilité>. Chaque région doit disposer d'au moins 50 Go de volume de blocs.
  6. Déterminez le nombre d'équilibreurs de charge flexibles dont vous disposez :
    • Filtrez sur les options suivantes :
      • Service : LbaaS
      • Portée : <your-region>. Exemple : us-ashburn-1
      • Ressource : <blank>
      • Compartiment : <tenancy-name> (racine)
    • Recherchez le nombre d'équilibreurs de charge flexibles disponibles :
      • Nom de la limite : lb-flexible-count
      • Disponible : 1 au minimum.
Remarque

Ce tutoriel crée trois instances de calcul avec la forme VM.Standard.E3.Flex pour les noeuds de cluster. Pour utiliser une autre forme, appliquez un filtre afin d'obtenir son nombre de coeurs. Par exemple, pour VM.Standard2.4, filtrez sur Coeurs pour les instances Bare Metal et de machine virtuelle basées sur Standard2 afin d'obtenir le nombre de coeurs.

Pour obtenir la liste de toutes les formes, reportez-vous à Formes standard de machine virtuelle.

Remarque

Ce tutoriel utilise un workflow de création rapide pour créer un cluster avec un sous-réseau régional public hébergeant un équilibreur de charge flexible. Pour utiliser un autre équilibreur de charge, vous pouvez avoir recours à un workflow personnalisé afin d'indiquer explicitement les ressources réseau existantes à employer, y compris les sous-réseaux existants dans lesquels créer les équilibreurs de charge.

Afin d'utiliser une autre bande passante pour l'équilibreur de charge, appliquez un filtre afin d'obtenir le nombre, par exemple, Bande passante de 100 Mbits/s ou Bande passante de 400 Mbits/s.

Création d'un jeton d'autorisation
  1. Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option que vous voyez.
  2. Cliquez sur Jetons d'authentification.
  3. Cliquez sur Générer un jeton.
  4. Indiquez une description.
  5. Cliquez sur Générer un jeton.
  6. Copiez le jeton et enregistrez-le.
  7. Cliquez sur Fermer.
Remarque

Veillez à enregistrer le jeton dès qu'il est créé. Vous ne pourrez plus y accéder ultérieurement.
Collecte des informations requises
  1. Collectez les informations d'identification suivantes à partir de la console Oracle Cloud Infrastructure.
    • Nom de location : <tenancy-name>
      • Dans la barre de navigation, sélectionnez le menu Profil, puis Location : <your_tenancy_name>.
    • Espace de noms de location : <tenancy-namespace>
      • Dans la barre de navigation, sélectionnez le menu Profil, puis Location : <your_tenancy_name>.
      • Copiez la valeur Espace de noms Object Storage.
      Remarque

      Pour certains comptes, l'espace de noms et le nom de la location diffèrent. Veillez à utiliser l'espace de noms dans ce tutoriel.
    • OCID de la location : <tenancy-ocid>
      • Dans la barre de navigation, sélectionnez le menu Profil, puis Location : <your_tenancy_name>.
      • Copiez l'OCID.
    • Nom utilisateur : <user-name>
      • Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option affichée.
    • OCID utilisateur : <user-ocid>
      • Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option affichée.
      • Copiez l'OCID.
  2. Recherchez les informations sur votre région.
    • Région : <region-identifier>
      • Dans la barre de navigation supérieure de la console, recherchez votre région. Exemple : Est des Etats-Unis (Ashburn).
      • Recherchez l'identificateur de région dans la table dans Régions et domaines de disponibilité.
      • Exemple : us-ashburn-1.
    • Clé de région : <region-key>
  3. Copiez le jeton d'authentification à partir de la section Création d'un jeton d'authentification.
    • Jeton d'authentification : <auth-token>
Configuration de l'interface de ligne de commande OCI
Installation d'un environnement virtuel Python et d'un wrapper

L'outil virtualenv Python crée un dossier contenant tous les exécutables et toutes les bibliothèques de votre projet.

L'outil virtualenvwrapper est une extension de virtualenv. Il fournit un ensemble de commandes, ce qui rend l'utilisation des environnements virtuels beaucoup plus agréable. Il place également tous les environnements virtuels au même endroit. virtualenvwrapper fournit une fonction de saisie semi-automatique par tabulation pour les noms d'environnement.

  1. Installez virtualenv.
    pip3 install --user virtualenv
  2. Installez virtualenvwrapper.
    pip3 install --user virtualenvwrapper
  3. Recherchez l'emplacement du script virtualenvwrapper.sh.
    grep -R virtualenvwrapper.sh
    Exemples de chemin :
    • Exemple Linux : /home/ubuntu/.local/bin/virtualenvwrapper.sh
    • Exemple macOS : /usr/local/bin/virtualenvwrapper.sh
  4. Configurez le wrapper d'environnement virtuel dans .bashrc.
    sudo vi .bashrc

    Ajoutez le texte suivant à la fin.

    # set up Python env
export WORKON_HOME=~/envs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
source <path-to-virtualenvwrapper.sh>

    Remplacez <path-to-virtualenvwrapper.sh> par la valeur de chemin correspondante.

    En fonction de l'emplacement des fichiers binaires Python3 dans l'environnement, remplacez /usr/bin/python3 par l'emplacement correct.

    Enregistrez le fichier.

  5. Activez les commandes dans la fenêtre active.
    source ~/.bashrc
    Exemple de sortie :
    virtualenvwrapper.user_scripts creating /home/ubuntu/envs/premkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postmkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/initialize
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/premkvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postmkvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/prermvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postrmvirtualenv
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/predeactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postdeactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/envs/postactivate
Installation de l'interface de ligne de commande OCI
  1. Démarrez un environnement virtuel.
    workon cli-app
  2. Vérifiez que le nom de l'environnement virtuel, cli-app, apparaît à gauche de l'invite de commande.

    Exemple : (cli-app) ubuntu@<nom-instance-ubuntu>:~$

  3. Installez l'interface de ligne de commande OCI.
    pip3 install oci-cli
  4. Testez l'installation :
    oci --version

    Si tout est correctement configuré, vous obtenez la version.

    oci --help
Configuration de l'interface de ligne de commande OCI
  1. Saisissez la commande suivante dans l'environnement virtuel :
    oci setup config
  2. Entrez vos réponses de la section Collecte des informations requises :
    • Emplacement de la configuration [$HOME/.oci/config] : <utiliser-valeur-par-défaut>
    • OCID utilisateur : <user-ocid>
    • OCID de la location : <tenancy-ocid>
    • Région (par exemple, us-ashburn-1) : <identificateur-de-région>
  3. Entrez les informations suivantes pour configurer les clés de cryptage d'API OpenSSL :
    • Générer une nouvelle paire de clés RSA de signature d'API ? [Y/N] : Y
    • Répertoire pour les clés [$HOME/.oci] : <utiliser-valeur-par-défaut>
    • Nom de la clé [oci_api_key] <utiliser-valeur-par-défaut>
  4. Désactivez l'environnement virtuel : 
    deactivate

    Le préfixe (cli-app) de votre environnement n'apparaît plus.

Remarque

La clé privée est oci_api_key.pem et la clé publique est oci_api_key_public.pem.
Ajout de la clé publique à votre compte utilisateur
  1. Activez l'environnement cli-app :
    workon cli-app
  2. Affichez la clé publique.
    cat $HOME/.oci/oci_api_key_public.pem
  3. Copiez la clé publique.
  4. Ajoutez la clé publique à votre compte utilisateur:
    • Accédez à la console.
    • Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option affichée.
    • Cliquez sur Clés d'API.
    • Cliquez sur Ajouter une clé d'API.
    • Cliquez sur Coller la clé publique.
    • Collez la valeur de l'étape précédente, y compris les lignes contenant BEGIN PUBLIC KEY et END PUBLIC KEY.
    • Cliquez sur Ajouter.
Remarque

  • Lorsque vous souhaitez utiliser l'interface de ligne de commande OCI, activez-la avec : workon cli-app
  • Lorsque vous modifiez des noms de projet, workon désactive l'environnement de travail en cours. Vous pouvez ainsi basculer rapidement entre les environnements.

2. Configuration d'un cluster

Installez et configurez les options de gestion pour le cluster Kubernetes. Ensuite, déployez l'application vers ce cluster.

Ajout d'une stratégie de compartiment

Si votre nom utilisateur figure dans le groupe Administrateurs, ignorez cette section. Sinon, demandez à l'administrateur d'ajouter la stratégie suivante à la location :

allow group <the-group-your-username-belongs> to manage compartments in tenancy

Avec ce privilège, vous pouvez créer un compartiment pour toutes les ressources du tutoriel.

Procédure d'ajout de la stratégie
  1. Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option affichée.
  2. Dans le panneau gauche, cliquez sur Groupes.
  3. Dans un bloc-notes, copiez le nom du groupe auquel votre nom utilisateur appartient.
  4. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Stratégies.
  5. Sélectionnez votre compartiment dans la liste déroulante Compartiment.
  6. Cliquez sur Créer une stratégie.
  7. Renseignez les informations suivantes :
    • Nom : manage-compartments
    • Description : Allow the group <the-group-your-username-belongs> to list, create, update, delete and recover compartments in the tenancy.
    • Compartiment : <your-tenancy>(root)
  8. Pour Générateur de stratégies, cliquez sur Afficher l'éditeur manuel.
  9. Collez la stratégie suivante :
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  10. Cliquez sur Créer.

Référence : type de ressource compartments dans Combinaisons de verbe et de type de ressource pour IAM

Création d'un compartiment

Créez un compartiment pour les ressources que vous allez créer dans ce tutoriel.

  1. Connectez-vous à la console Oracle Cloud Infrastructure.
  2. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Compartiments.
  3. Cliquez sur Créer un compartiment.
  4. Renseignez les informations suivantes :
    • Nom : <your-compartment-name>
    • Description : Compartiment pour <votre-description>.
    • Compartiment parent : <votre-location>(racine)
  5. Cliquez sur Créer un compartiment.

Référence : Création d'un compartiment

Ajout d'une stratégie de ressource

Si votre nom utilisateur figure dans le groupe Administrateurs, ignorez cette section. Sinon, demandez à l'administrateur d'ajouter la stratégie suivante à la location :

allow group <the-group-your-username-belongs> to manage all-resources in compartment <your-compartment-name>

Avec ce privilège, vous pouvez gérer toutes les ressources de votre compartiment, ce qui vous donne fondamentalement des droits d'administration dans ce compartiment.

Procédure d'ajout de la stratégie
  1. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Stratégies.
  2. Sélectionnez votre compartiment dans la liste déroulante Compartiment.
  3. Cliquez sur Créer une stratégie.
  4. Renseignez les informations suivantes :
    • Nom : manage-<your-compartment-name>-resources
    • Description : Autoriser les utilisateurs à répertorier, créer, mettre à jour et supprimer des ressources dans <nom-du-compartiment>.
    • Compartiment : <your-tenancy>(root)
  5. Pour Générateur de stratégies, sélectionnez les options suivantes :
    • Cas d'emploi de stratégie : Gestion des compartiments
    • Modèles de stratégie courante : Autoriser les administrateurs de compartiment à gérer le compartiment
    • Groupes : <the-group-your-username-belongs>
    • Emplacement : <your-tenancy>(root)
  6. Cliquez sur Créer.

Référence : Politiques courantes

Création d'un cluster avec le workflow Création rapide

Créez un cluster avec des paramètres par défaut et de nouvelles ressources réseau via le workflow Création rapide.

  1. Connectez-vous à la console Oracle Cloud Infrastructure.
  2. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Conteneurs et artefacts, cliquez sur Clusters Kubernetes (OKE).
  3. Cliquez sur Créer un cluster.
  4. Sélectionnez Création rapide.
  5. Cliquez sur Lancer le workflow.

    La boîte de dialogue Création rapide de cluster apparaît.

  6. Renseignez les informations suivantes .
    • Nom : <your-cluster-name>
    • Compartiment : <your-compartment-name>
    • Version Kubernetes : <take-default>
    • Adresse d'API Kubernetes : Adresse publique

      Le cluster Kubernetes est hébergé dans un sous-réseau public avec une adresse IP publique affectée automatiquement.

    • Noeuds de processus actif Kubernetes : processus actifs privés

      Les noeuds de processus actif Kubernetes sont hébergés dans un sous-réseau privé.

    • Forme : VM.Standard.E3.Flex
    • Sélectionner le nombre d'OCPU : 1
    • Quantité de mémoire (Go) : 16
    • Nombre de noeuds : 3
  7. Cliquez sur Afficher les options avancées.

    Conservez les valeurs par défaut.

    • Indiquer une taille personnalisée de volume d'initialisation : décochez la case.
    • Vérification d'image : désélectionnez la case.
    • Ajouter une clé SSH : Aucune clé SSH
  8. Cliquez sur Suivant.

    Tous vos choix sont affichés. Vérifiez-les pour vous assurer que tout est configuré correctement.

  9. Cliquez sur Créer un cluster.

    Les services configurés pour le cluster sont affichés.

  10. Cliquez sur Fermer.
  11. Préparez-vous une tasse de café. La création du cluster prend quelques minutes.
Vous avez créé un cluster Kubernetes.
Configuration de l'accès local au cluster

Après avoir créé un cluster Kubernetes, configurez votre système local de sorte à accéder au cluster.

  1. Connectez-vous à la console Oracle Cloud Infrastructure.
  2. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Conteneurs et artefacts, cliquez sur Clusters Kubernetes (OKE).
  3. Cliquez sur le lien vers <votre-cluster>.

    Les informations relatives au cluster apparaissent.

  4. Cliquez sur Accéder au cluster.
  5. Cliquez sur Accès local.
  6. Suivez les étapes indiquées dans la boîte de dialogue. Elles sont indiquées ici pour référence.
    Remarque

    Si vous n'êtes pas dans l'environnement virtuel, saisissez workon cli-app avant d'exécuter les commandes kubectl.

    Vérifiez votre version de l'interface de ligne de commande oci.

    oci -v

    Créez un répertoire .kube s'il n'en existe pas.

    mkdir -p $HOME/.kube

    Créez un fichier kubeconfig pour la configuration. Utilisez les informations de la boîte de dialogue Accéder à votre cluster.

    oci ce cluster create-kubeconfig <use data from dialog>

    Exportez la variable d'environnement KUBECONFIG.

    export KUBECONFIG=$HOME/.kube/config
    Remarque

    Si vous souhaitez que la variable d'environnement démarre dans un nouveau shell, ajoutez export KUBECONFIG=$HOME/.kube/config au fichier ~/.bashrc.
  7. Testez la configuration du cluster à l'aide des commandes suivantes.

    Répertoriez les clusters :

    kubectl get service

    Obtenez les détails du déploiement :

    kubectl describe deployment

    Obtenez les pods :

    kubectl get pods
    Remarque

    Etant donné qu'aucune application n'est déployée, les deux dernières commandes génèrent un message indiquant qu'aucune ressource n'a été trouvée dans l'espace de noms par défaut.
    Remarque

    Pour consulter un autre cluster, spécifiez un autre fichier de configuration sur la ligne de commande. Exemple :
    kubectl --kubeconfig=</path/to/config/file>

L'accès au cluster étant configuré, vous pouvez maintenant préparer l'application pour le déploiement.

3. Création d'une application locale

Créez une application locale et une image Docker pour l'application.

Création d'une application locale

Créez votre application Node.js.

  1. Démarrez une session d'interface de ligne de commande OCI.
  2. Créez un répertoire pour l'application. 
    mkdir node-hello-app
cd node-hello-app
  3. Créez un fichier package.json .

    Créez le fichier :

    vi package.json

    Dans le fichier, saisissez le texte suivant, mettez à jour les champs facultatifs auteur et référentiel, puis enregistrez le fichier :

    {
    "name": "node-hello-app",
    "version": "1.0.0",
    "description": "Node Express Hello application",
    "author": "Example User <username@example.com>",
    "main": "app.js",
    "scripts": {
        "start": "node app.js"
    },
    "repository": {
        "type": "git",
        "url": "git://github.com/username/repository.git"
    },
    "dependencies": {
        "express": "^4.0.0"
    },
    "license": "UPL-1.0"
}
  4. Installez les packages NPM. 
    npm install
  5. Créez une application "Hello, World!".

    Créez le fichier :

    vi app.js

    Saisissez le texte ci-dessous dans le fichier, puis enregistrez ce dernier :

    const express = require('express')
const app = express()
port = 3000

app.get('/', function (req, res) {
    res.send('<h1>Hello World from Node.js!</h1>')
})

app.listen(port, function() {
    console.log('Hello World app listening on port ' + port);
})

Vous avez configuré votre application Node.js.

Exécution de l'application locale

Exécutez votre application Node.js.

  1. Exécutez votre application Node.js. 
    node app.js
    Le serveur Node Express démarre et affiche ce qui suit : 
    Hello World app listening on port 3000
  2. Testez l'application à l'aide de curl ou de votre navigateur.
    • Pour effectuer le test avec curl, saisissez ce qui suit : 
      curl -X GET http://localhost:3000
    • Pour effectuer le test avec votre navigateur, connectez une fenêtre de navigateur à l'adresse suivante : http://<votre-adresse-ip>:3000 (facultatif).
    L'application renvoie ce qui suit : 
    <h1>Hello World from Node.js!</h1>
  3. Arrêtez l'application en cours d'exécution.

    Appuyez sur Ctrl+C pour arrêter votre application dans la fenêtre de terminal avec laquelle vous avez commencé.

Vous avez créé une application Hello World à l'aide de Node.js et d'Express.

Références :

Création d'une image Docker

A présent, créez une image Docker pour l'application Node.js Express.

  1. Assurez-vous que vous êtes dans le répertoire node-hello-app.
  2. Créez une image Docker . 
    docker build -t node-hello-app .

    Un message de succès s'affiche.

    [INFO] BUILD SUCCESS
Successfully tagged node-hello-app:latest
  3. Exécutez l'image Docker : 
    docker run --rm -p 3000:3000 node-hello-app:latest
  4. Testez l'application. 
    curl -X GET http://localhost:3000
    L'application renvoie ce qui suit : 
    <h1>Hello World from Node.js!</h1>
  5. Arrêtez l'application en cours d'exécution.
Félicitations ! Vous avez créé une image Node.js Express.

4. Déploiement de l'image Docker

Propagez votre image Node.js Express vers OCI Container Registry. Ensuite, utilisez l'image pour déployer l'application.

Création d'un référentiel Docker
  1. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Conteneurs et artefacts, cliquez sur Registre du conteneur.
  2. Dans la zone de navigation de gauche, sélectionnez <nom-du-compartiment>.
  3. Cliquez sur Créer un référentiel.
  4. Créez un référentiel privé portant le nom de votre choix : 
    <repo-name> = <image-path-name>/<image-name>

    Exemple : node-apps/node-hello-app

    Vous êtes maintenant prêt à propager votre image locale vers Container Registry.
    Remarque

    Pour pouvoir propager une image Docker vers un référentiel de registre, le référentiel doit exister dans votre compartiment. Si le référentiel n'existe pas, la commande push Docker ne fonctionne pas correctement.
    Remarque

    Dans un nom de référentiel, la barre oblique ne représente pas une structure de répertoire hiérarchique. Le nom de chemin d'image facultatif (<image-path-name>) permet d'organiser les référentiels.
Propagation de l'image locale

Une fois l'image Docker locale créée, propagez-la vers le registre de conteneur.

Suivez les étapes ci-après.

  1. Ouvrez la session d'interface de ligne de commande OCI.
  2. Connectez-vous à OCI Container Registry : 
    docker login <region-key>.ocir.io

    Vous êtes invité à saisir le nom et le mot de passe de connexion.

    • Nom utilisateur : <tenancy-namespace>/<user-name>
    • Mot de passe : <auth-token>
  3. Répertoriez les images Docker locales : 
    docker images

    Les images Docker du système sont affichées. Identifiez l'image que vous avez créée dans la dernière section : node-hello-app

  4. Balisez l'image locale avec l'URL du registre et le nom du référentiel afin de pouvoir la propager vers ce référentiel. 
    docker tag <your-local-image> <repo-url>/<repo-name>
    • Remplacez <repo-url> par ce qui suit : 
      <region-key>.ocir.io/<tenancy-namespace>/
    • Remplacer <repo-name> par ce qui suit :

      <nom-dossier-image>/<nom-image> dans la section Création d'un référentiel Docker.

    • Voici un exemple de combinaison des deux éléments :
      docker tag node-hello-app iad.ocir.io/my-namespace/node-apps/node-hello-app

      Dans cet exemple, les composants sont les suivants :

      • URL de référentiel : iad.ocir.io/my-namespace/
      • Nom de référentiel : node-apps/node-hello-app
    Remarque

    OCI Container Registry prend désormais en charge la création de référentiel de registre dans n'importe quel compartiment, et pas uniquement dans le compartiment racine (location). Pour propager l'image vers le référentiel que vous avez créé, combinez l'URL du registre avec le nom exact du référentiel. OCI Container Registry met en correspondance le nom de référentiel unique et propage votre image.
  5. Consultez les images Docker pour voir si l'image est copiée. 
    docker images
    • L'image balisée a le même ID d'image que l'image locale.
    • Le nom de l'image balisée est le suivant : 
      <region-key>.ocir.io/<tenancy-namespace>/<image-path-name>/<image-name>
  6. Propagez l'image vers Container Registry. 
    docker push <copied-image-name>:latest
    Exemple :
    docker push iad.ocir.io/my-namespace/node-apps/node-hello-app:latest
  7. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Conteneurs et artefacts, cliquez sur Registre du conteneur.

Recherchez votre image dans Container Registry une fois la commande push terminée.

Déploiement de l'image
Une fois que votre image se trouve dans Container Registry, vous pouvez la déployer, de même que votre application.
  1. Créez une clé secrète de registre pour l'application. Cette clé secrète authentifie l'image lorsque vous la déployez vers votre cluster.

    Pour créer une clé secrète, renseignez les informations dans ce modèle.

    kubectl create secret docker-registry ocirsecret --docker-server=<region-key>.ocir.io  --docker-username='<tenancy-namespace>/<user-name>' --docker-password='<auth-token>'  --docker-email='<email-address>'

    Une fois la commande exécutée, un message semblable à celui-ci s'affiche : secret/ocirsecret created.

  2. Vérifiez que la clé secrète a été créée. Emettez la commande suivante: 
    kubectl get secret ocirsecret --output=yaml

    La sortie inclut des informations sur la clé secrète au format YAML.

  3. Déterminez l'URL d'hôte de l'image de registre à l'aide du modèle suivant: 
    <region-code>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>
    Exemple :
    iad.ocir.io/my-namespace/node-apps/node-hello-app:latest
  4. Sur votre système, créez un fichier nommé node-app.yaml avec le texte suivant :
    Remplacez les espaces réservés suivants :
    • <your-image-url> (URL de l'image)
    • <your-secret-name> (nom de la clé secrète)
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  selector:
    matchLabels:
      app: app
  replicas: 3
  template:
    metadata:
      labels:
        app: app
    spec:
      containers:
      - name: app
        image: <your-image-url>
        imagePullPolicy: Always
        ports:
        - name: app
          containerPort: 3000
          protocol: TCP
      imagePullSecrets:
        - name: <your-secret-name>
---
apiVersion: v1
kind: Service
metadata:
  name: node-app-lb
  labels:
    app: app
  annotations:
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 3000
  selector:
    app: app
  5. Déployez l'application avec la commande suivante . 
    kubectl create -f node-app.yaml
    Sortie : 
    deployment.apps/node-app created
service/node-app-lb created
    Remarque

    Dans le fichier node-app.yaml, le code après les tirets ajoute un équilibreur de charge flexible.
Test de votre application
Une fois l'application déployée, le chargement de l'équilibreur de charge peut prendre quelques secondes.
  1. Vérifiez si l'équilibreur de charge est actif : 
    kubectl get service

    Répétez la commande jusqu'à ce qu'une adresse IP soit affectée à l'équilibreur de charge.

    Remarque

    En attendant le déploiement de l'équilibreur de charge, vous pouvez vérifier le statut du cluster à l'aide des commandes suivantes :
    • Pour obtenir le statut de chaque pod : kubectl get pods
    • Pour obtenir le statut de l'application : kubectl get deployment
  2. Utilisez l'adresse IP de l'équilibreur de charge pour vous connecter à l'application dans un navigateur : 
    http://<load-balancer-IP-address>:3000

    Le navigateur affiche : <h1>Hello World from Node.js!</h1>

  3. Annulez le déploiement de l'application vers le cluster. (Facultatif) Pour enlever l'application, exécutez la commande suivante : 
    kubectl delete -f node-app.yaml
    Sortie :
    deployment.apps/node-app deleted
service "node-app-lb" deleted

    L'application a été enlevée du cluster.

Etapes suivantes

Vous avez créé une application Hello World, vous l'avez déployée vers un cluster Kubernetes et vous l'avez rendue accessible sur Internet à l'aide de la structure Node Express.

Consultez les sites suivants pour obtenir plus d'informations sur le développement avec les produits Oracle :