Kubernetes : Déployer une application Node Express

Dans ce tutoriel, vous utiliserez un compte Oracle Cloud Infrastructure pour configurer une grappe Kubernetes. Ensuite, vous déploierez une application Node Express dans votre grappe.

Voici les principales tâches :

Configurer une grappe Kubernetes sur OCI.
Configurer l'interface CLI OCI pour accéder à votre grappe.
Créer une application Node Express et une image Docker.
Pousser votre image vers OCIR.
Déployer votre application Docker Node.js dans votre grappe.
Vous connecter à votre application à partir d'Internet.

Schéma des composants nécessaires pour exécuter une application NodeJS Express sur Oracle Cloud Infrastructure Kubernetes Engine

Pour plus d'informations, voir :

Étapes préliminaires

Pour suivre ce tutoriel, vous devez disposer des éléments suivants :

Exigences

Pour le registre de conteneurs, Kubernetes et les équilibreurs de charge :
- Un compte Oracle Cloud Infrastructure payant.
- Voir Inscription à Oracle Cloud Infrastructure.
Pour créer des applications et des images Docker :
- L'un des environnements locaux suivants :
  - Une machine MacOS ou Linux.
  - Une machine Windows prenant en charge Linux. Par exemple :
    - Sous-système Windows pour Linux
    - Oracle Virtual Box
- Les applications suivantes sur votre environnement local :
  - JDK 11, et définissez JAVA_HOME dans .bashrc.
  - Le programme d'installation de Python 3.6.8+ et pip pour Python 3
  - Kubernetes Client 1.11.9+
  - Apache Maven 3.0+
  - Docker 19.0.3+
  - Git 1.8+
  - Node.js 10+

Obtenir les applications pour Linux dans le cadre de l'offre de gratuité pour OCI

Si vous souhaitez utiliser une instance de calcul Linux gratuite pour OCI afin de gérer votre déploiement, consultez les sections suivantes pour savoir comment installer les logiciels requis.

Installer une instance Linux

Installation d'une machine virtuelle Linux sur Oracle Cloud Infrastructure à l'aide d'une forme de calcul de type Toujours gratuit. Vous aurez besoin d'une machine prenant en charge ssh pour vous connecter à votre instance Linux.
- Installer une machine virtuelle Oracle Linux
  - Suivez les sections 2 et 3.
  - Si vous disposez d'un compte payant, pour la section 2, sélectionnez vos options de calcul en fonction de vos offres.
  - Pour vous connecter à votre instance, effectuez les étapes 1 à 5 de la section 4.
  - Ignorez les instructions Apache.
- Installer une machine virtuelle Ubuntu

Installer Node.js

Installez Node.js sur votre système.

Exécuter les commandes d'installation

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

Oracle Linux :
```
sudo yum update
```
Configurez le référentiel Yum pour Node.js. Installez ensuite l'ensemble nodejs.
```
sudo yum install -y oracle-nodejs-release-el7
sudo yum install -y nodejs
```

Ubuntu :

sudo apt update

Installez les ensembles nodejs et npm.

sudo apt install -y nodejs
sudo apt install -y npm

Vérifiez l'installation.
```
node -v
npm -v
```

Configurer le pare-feu (facultatif)

Si vous voulez tester votre application Node Express à l'aide d'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éer une règle de trafic entrant pour votre VCN (facultatif)

Procédez de la façon suivante pour sélectionner le sous-réseau public de votre VCN et ajouter la règle de trafic entrant.

Ouvrez le menu de navigation et cliquez sur Service de réseau, puis sur Réseaux en nuage virtuels.
Sélectionnez le VCN que vous avez créé avec votre instance de calcul.
Maintenant que votre nouveau VCN est affiché, cliquez sur le lien de sous-réseau <your-subnet-name>.
Les informations sur le sous-réseau public s'affichent avec les listes de sécurité au bas de la page. Un lien vers la liste de sécurité par défaut de votre VCN est présent.
Cliquez sur le lien Liste de sécurité par défaut.
Les règles de trafic entrant par défaut pour votre VCN s'affichent.
Cliquez sur Ajouter des règles de trafic entrant.
Une boîte de dialogue Ajouter des règles de trafic entrant s'affiche.
Entrez les informations suivantes pour la règle de trafic entrant.
Définissez la règle de trafic entrant comme suit :
- Sans état : Coché
- Type de source : CIDR
- CIDR source : 0.0.0.0/0
- Protocole IP : TCP
- Intervalle de ports sources : (Laissez vide)
- Intervalle de ports de destination : 3000
- Description : Autoriser les connexions HTTP
Cliquez sur Ajouter une règle de trafic entrant.
À présent, les connexions HTTP sont autorisées. Votre VCN est configuré pour Node Express.

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

Installer Python 3 et Pip 3

Vérifiez votre installation courante.
```
python3 --version
```

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

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)
```

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

Vérifiez l'installation de pip pour Python 3.
```
pip3 -V
```

Installer le client Kubernetes

Vérifiez votre installation courante :
```
kubectl version --client
```
Si vous disposez de Kubernetes, la version est <major-version>.<minor-version>. Par exemple, pour la version 1.20, voici ce que vous obtenez :
```
version.Info{Major:"1", Minor:"20"...
```
Pour installer le client kubectl, consultez les liens suivants :
- Installer le client Kubernetes sur Linux
- Installer le client Kubernetes sur MacOS
Vérifiez l'installation.
```
kubectl version --client
```

Installer Docker

Vérifiez votre installation courante :
```
docker -v
```
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
```
Note : La dernière commande permet à Docker de démarrer au redémarrage.
Ubuntu Linux
Pour installer Docker sur Ubuntu Linux, consultez le lien suivant : Obtenir Docker
Vérifiez l'installation.
```
docker -v
```

1. Préparer

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

Vérifier vos limites de service

Connectez-vous à la console Oracle Cloud Infrastructure.
Ouvrez le menu de navigation et cliquez sur Gouvernance et administration. Sous Gouvernance, cliquez sur Limites, quotas et utilisation.
Déterminez votre limite de service pour Régions :
- Filtrez les options suivantes :
  - Service : Régions
  - Portée : Location
  - Source : Nombre de régions abonnées
  - compartiment : <tenancy-name> (root)
- Recherchez la limite de service :
  - Nom de la limite : subscribed-region-count
  - Limite de service : 2 au minimum
Nombre de coeurs de calcul disponibles pour VM.Standard.E3. Forme flexible :
- Filtrez les options suivantes :
  - Service : Calcul
  - Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
  - Ressource : Coeurs pour Standard.E3. Instances Flex et BM.Standard.E3.128
  - compartiment : <tenancy-name> (root)
- Recherchez le nombre de coeurs disponibles :
  - Nom de la limite : standard-e3-core-ad-count
  - Disponible : 1 au moins
- Répétez l'opération pour Portée : <second-availability-domain> et <third-availability-domain>. Chaque région doit comporter au moins un coeur disponible pour cette forme.
Découvrez si vous disposez de 50 Go de volume par blocs disponibles :
- Filtrez les options suivantes :
  - Service : Volume par blocs
  - Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
  - Taille du volume de ressource (Go)
  - compartiment : <tenancy-name> (root)
- Déterminez le stockage de volume par blocs dont vous disposez :
  - Nom de la limite : total-storage-gb
  - Disponible : 50 au minimum
- Répétez l'opération pour Portée : <second-availability-domain> et <third-availability-domain>. Chaque région doit disposer d'au moins 50 Go de volume par blocs disponibles.
Déterminez le nombre d'équilibreurs de charge flexibles dont vous disposez :
- Filtrez les options suivantes :
  - Service : LbaaS
  - Portée : <your-region>. Exemple : us-ashburn-1
  - Source : <blank>
  - compartiment : <tenancy-name> (root)
- Déterminez le nombre d'équilibreurs de charge flexibles disponibles :
  - Nom de la limite : lb-flexible-count
  - Disponible : 1 au moins

Note

Ce tutoriel crée trois instances de calcul avec un VM.Standard.E3. Forme flexible pour les noeuds de grappe. Pour utiliser une autre forme, définissez un filtre pour son nombre de coeurs. Par exemple, pour VM.Standard2.4, définissez un filtre pour Coeurs pour les instances de machine virtuelle et sans système d'exploitation basées sur Standard2 et obtenez le nombre.

Pour obtenir la liste de toutes les formes, voir Formes standard de machine virtuelle.

Note

Ce tutoriel utilise un flux de travail de création rapide pour créer une grappe avec un sous-réseau régional public qui héberge un équilibreur de charge flexible. Pour utiliser un autre équilibreur de charge, vous pouvez utiliser un flux de travail personnalisé afin de spécifier explicitement les ressources de réseau existantes à utiliser, y compris les sous-réseaux existants dans lesquels créer les équilibreurs de charge.

Pour utiliser une autre bande passante pour l'équilibreur de charge, définissez un filtre pour son nombre, par exemple Bande passante de 100 Mbit/s ou Bande passante de 400 Mbit/s.

Créer un jeton d'autorisation

Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
Cliquez sur Jetons d'authentification.
Cliquez sur Générer un jeton.
Indiquez une description.
Cliquez sur Générer un jeton.
Copiez le jeton et enregistrez-le.
Cliquez sur Fermer.

Note

Enregistrez votre jeton juste après l'avoir créé. Vous ne pourrez plus y accéder ultérieurement.

Collecter les informations requises

Collectez les informations de données d'identification suivantes à partir de la console Oracle Cloud Infrastructure.
- Nom de la location : <tenancy-name>
  - Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Location : <your_tenancy_name>.
- L'espace de noms de la location : <tenancy-namespace>
  - Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Location : <your_tenancy_name>.
  - Copiez la valeur de Espace de noms du stockage d'objets.
  Note
  
  Pour certains comptes, le nom et l'espace de noms de la location sont différents. Veillez à utiliser l'espace de noms dans ce tutoriel.
- OCID de la location : <tenancy-ocid>
  - Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Location : <your_tenancy_name>.
  - Copier l'OCID.
- Nom d'utilisateur : <user-name>
  - Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
- OCID d'utilisateur : <user-ocid>
  - Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
  - Copier l'OCID.
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 : US East (Ashburn).
  - Recherchez l'identificateur de votre région dans le tableau de la région et domaine de disponibilité.
  - Exemple : us-ashburn-1.
- Clé de région : <region-key>
  - Recherchez la clé de votre région dans le tableau de la rubrique Régions et domaines de disponibilité.
  - Exemple : iad
Cliquez sur le lien Créer un jeton d'authentification.
- Jeton d'authentification : <auth-token>

Configurer l'interface de ligne de commande OCI

Installer un environnement virtuel Python et un encapsuleur d'environnement virtuel Python

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

L'encapsuleur virtualenvwrapper est une extension de virtualenv. Il fournit un ensemble de commandes, ce qui rend le travail avec des environnements virtuels beaucoup plus agréable. De plus, il réunit tous vos environnements virtuels au même endroit. L'encapsuleur virtualenvwrapper active le remplissage à l'aide de la touche de tabulation pour les noms d'environnement.

Installez virtualenv.
```
pip3 install --user virtualenv
```
Installez virtualenvwrapper.
```
pip3 install --user virtualenvwrapper
```
Recherchez l'emplacement du script virtualenvwrapper.sh.
```
grep -R virtualenvwrapper.sh
```
Exemples de chemins :
- Exemple pour Linux : /home/ubuntu/.local/bin/virtualenvwrapper.sh
- Exemple pour MacOS : /usr/local/bin/virtualenvwrapper.sh
Configurez l'encapsuleur d'environnement virtuel dans. bashrc.
```
sudo vi .bashrc
```
Ajoutez le texte suivant.
```
# 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 sa valeur.
En fonction de l'emplacement des binaires Python3 dans votre environnement, mettez à jour /usr/bin/python3 avec son emplacement correct.
Enregistrez le fichier.

Activez les commandes dans la fenêtre courante.

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

Installer l'interface CLI OCI

Démarrez un environnement virtuel.
```
workon cli-app
```
Vérifiez que le nom de votre environnement virtuel, cli-app, précède votre invite de commande.
Exemple : (cli-app) ubuntu@<ubuntu-instance-name:~$
Installez l'interface CLI OCI.
```
pip3 install oci-cli
```
Testez l'installation :
```
oci --version
```
Si tout est configuré correctement, la version s'affiche.
```
oci --help
```

Configurer l'interface CLI OCI

Entrez la commande suivante dans votre environnement virtuel :
```
oci setup config
```
Entrez vos réponses obtenues à la section Collaborer les informations requises :
- Emplacement de votre configuration [$HOME/.oci/config] : <take-default>
- OCID d'utilisateur : <user-ocid>
- OCID de la location : <tenancy-ocid>
- région (par exemple, us-ashburn-1) : <region-identifier>
Entrez les informations suivantes pour configurer vos clés de chiffrement d'API OpenSSL :
- Generate a new API Signing RSA key pair? [Y/n] : O (Oui)
- Répertoire de vos clés [$HOME/.oci] : <take-default>
- Nom de votre clé [oci_api_key] <take-default>
Désactivez l'environnement virtuel :
```
deactivate
```
Le préfixe (cli-app) n'est plus affiché devant le nom de votre environnement.

Note

Votre clé privée est oci_api_key.pem et votre clé publique est oci_api_key_public.pem.

Ajouter la clé publique à votre compte d'utilisateur.

Activez l'environnement cli-app :
```
workon cli-app
```
Affichez la clé publique.
```
cat $HOME/.oci/oci_api_key_public.pem
```
Copiez la clé publique.
Ajoutez la clé publique à votre compte d'utilisateur :
- Allez à la console.
- Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
- Cliquez sur Clé 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.

Note

Chaque fois que vous souhaitez utiliser l'interface CLI OCI, activez-la en tapant : workon cli-app
Lorsque vous modifiez des noms de projet, workon désactive votre environnement de travail courant. De cette façon, vous pouvez rapidement passer d'un environnement à l'autre.

2. Configurer une grappe

Installez et configurez des options de gestion pour votre grappe Kubernetes. Plus tard, vous déploierez votre application dans cette grappe.

Ajouter une politique de compartiment

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

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

Grâce à ce privilège, vous pouvez créer un compartiment pour toutes les ressources de votre tutoriel.

Étapes d'ajout de la politique

Dans le menu de navigation , sélectionnez le menu Profil , puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
Dans le volet de gauche, cliquez sur Groupes.
Dans un carnet, copiez le nom de groupe auquel appartient votre nom d'utilisateur.
Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous identité, cliquez sur Politiques.
Sélectionnez votre compartiment dans la liste déroulante Compartiments.
Cliquez sur Créer une politique.
Entrez les informations suivantes :
- Name: 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)
Pour Générateur de politiques, cliquez sur Afficher l'éditeur manuel.

Collez la politique suivante :

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

Cliquez sur Créer.

Référence : Type de ressource compartments dans combinaisons verbes + type de ressource pour IAM

Créer un compartiment

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

Se connecter à la console Oracle Cloud Infrastructure.
Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Compartiments.
Cliquez sur Créer un compartiment.
Entrez les informations suivantes :
- Nom : <your-compartment-name>
- Description : Compartment for <your-description>.
- compartiment parent : <your-tenancy>(root)
Cliquez sur Créer un compartiment.

Inférence : Créez un compartiment

Ajouter une politique de ressource

Si votre nom d'utilisateur figure dans le groupe Administrateurs, ignorez cette section. Sinon, demandez à votre administrateur d'ajouter la politique suivante à votre 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 accorde essentiellement des droits administratifs sur celui-ci.

Étapes d'ajout de la politique

Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous identité, cliquez sur Politiques.
Sélectionnez votre compartiment dans la liste déroulante Compartiments.
Cliquez sur Créer une politique.
Entrez les informations suivantes :
- Nom : manage-<your-compartment-name>-resources
- Description : Allow users to list, create, update, and delete resources in <your-compartment-name>.
- Compartiment : <your-tenancy>(root)
Pour Générateur de politiques, sélectionnez les options suivantes :
- Cas d'utilisation de politique : Compartment Management
- Modèles de politique commune : Let compartment admins manage the compartment
- Groupes : <the-group-your-username-belongs>
- Emplacement : <your-tenancy>(root)
Cliquez sur Créer.

Informations de référence : Politiques communes

Créer une grappe à l'aide de 'Création rapide'

Créez une grappe avec les paramètres par défaut et de nouvelles ressources de réseau au moyen du flux de travail "Création rapide".

Connectez-vous à la console Oracle Cloud Infrastructure.
Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Conteneurs et artefacts, cliquez sur Grappes Kubernetes (OKE).
Cliquez sur Créer une grappe.
Sélectionnez Création rapide.
Cliquez sur Lancer le flux de travail.

La boîte de dialogue Quick Create Cluster s'affiche.
Entrez les informations suivantes .
- Nom : <your-cluster-name>
- compartiment : <your-compartment-name>
- Version de Kubernetes : <take-default>
- Point d'extrémité d'API Kubernetes : Point d'extrémité d'API public
  La grappe Kubernetes sera hébergée dans un sous-réseau public avec une adresse IP publique affectée automatiquement.
- Noeuds de travail Kubernetes : Noeuds de travail privés
  Les noeuds de travail Kubernetes seront 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
Cliquez sur Afficher les options avancées.
Conservez les valeurs par défaut.
- Définir une taille de volume de démarrage personnalisée : Cochez cette case.
- Vérification d'image : Désélectionnez la case.
- Ajouter une clé SSH : Aucune clé SSH.
Cliquez sur Next (Suivant).

Tous vos choix sont affichés. Vérifiez-les pour vous assurer que tout est configuré correctement.
Cliquez sur Créer une grappe.

Les services configurés pour votre grappe s'affichent.
Cliquez sur Fermer.
Faites une pause. La création de la grappe prend quelques minutes.

Vous avez créé une grappe Kubernetes.

Configurer l'accès local à votre grappe

Après avoir créé une grappe Kubernetes, configurez votre système local pour l'accès à la grappe.

Connectez-vous à la console Oracle Cloud Infrastructure.
Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Conteneurs et artefacts, cliquez sur Grappes Kubernetes (OKE).
Cliquez sur le lien vers <your-cluster>.

Les informations sur votre grappe s'affichent.
Cliquez sur Accéder à la grappe.
Cliquez sur Accès local.
Suivez les étapes indiquées dans la boîte de dialogue. Elles sont rappelées ici pour référence.

Note

Si vous n'êtes pas dans votre environnement virtuel, entrez : workon cli-app avant d'exécuter des commandes kubectl.
Vérifiez la version de votre interface CLI oci.
```
oci -v
```
Créez un répertoire .kube s'il n'existe pas.
```
mkdir -p $HOME/.kube
```
Créez un fichier kubeconfig pour votre configuration. Utilisez les informations de la boîte de dialogue Accéder à votre grappe .
```
oci ce cluster create-kubeconfig <use data from dialog>
```
Exportez la variable d'environnement KUBECONFIG.
```
export KUBECONFIG=$HOME/.kube/config
```
Note

Si vous voulez que la variable d'environnement démarre dans un nouveau shell, ajoutez export KUBECONFIG=$HOME/.kube/config à votre fichier ~/.bashrc.
Testez la configuration de votre grappe à l'aide des commandes suivantes.
Listez les grappes :
```
kubectl get service
```
Obtenez les informations détaillées sur le déploiement :
```
kubectl describe deployment
```
Obtenez des pods :
```
kubectl get pods
```
Note

Comme aucune application n'est déployée, les deux dernières commandes génèrent le message : "Aucune ressource trouvée dans l'espace de noms par défaut."
Note

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

Maintenant que vous avez configuré l'accès à la grappe, vous pouvez préparer votre application pour le déploiement.

3. Créer une application locale

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

Créer une application locale

Créez votre application Node.js.

Démarrez une session d'interface de ligne de commande OCI.
Créez un répertoire pour votre application.
```
mkdir node-hello-app
cd node-hello-app
```

Créez un fichier package.json .

Créez le fichier :

vi package.json

Entrez le texte suivant et mettez à jour les champs author et repository facultatifs dans le fichier, puis enregistrez celui-ci :

{
    "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"
}

Installez les ensembles NPM.
```
npm install
```

Créez une application "Hello, World!".

Créez le fichier :

vi app.js

Saisissez le texte suivant dans le fichier et enregistrez celui-ci :

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écuter l'application locale

Exécutez votre application Node.js.

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
```
Testez l'application à l'aide de curl ou de votre navigateur.
- Pour tester l'application à l'aide de curl, entrez :
```
curl -X GET http://localhost:3000
```
- Pour tester l'application à l'aide de votre navigateur, connectez une fenêtre du navigateur à : http://<your-ip-address>:3000 (facultatif).
L'application retourne
```
<h1>Hello World from Node.js!</h1>
```
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 démarré.

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

Références :

Pour des informations détaillées sur cet exemple, voir Introduction à Express.

Créer une image Docker

Créez ensuite une image Docker pour votre application Express Node.js.

Assurez-vous que vous êtes dans le répertoire node-hello-app.

Créez une image Docker .

docker build -t node-hello-app .

Vous obtenez un message de réussite.

[INFO] BUILD SUCCESS
Successfully tagged node-hello-app:latest

Exécutez l'image Docker :

docker run --rm -p 3000:3000 node-hello-app:latest

Testez l'application.

curl -X GET http://localhost:3000

L'application retourne

<h1>Hello World from Node.js!</h1>

Arrêtez l'application en cours d'exécution.

Félicitations! Vous avez créé une image Express Node.js.

4. Déployer votre image Docker

Poussez votre image Express Node.js vers le registre de conteneurs pour OCI. Utilisez ensuite l'image pour déployer votre application.

Créer un référentiel Docker

Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Conteneurs et artificiels, cliquez sur Container Registry.
Dans le panneau de navigation de gauche, sélectionnez <your-compartment-name>.
Cliquez sur Créer un référentiel.
Créez un référentiel privé avec le nom de votre choix :
```
<repo-name> = <image-path-name>/<image-name>
```
Exemple : node-apps/node-hello-app
À présent, vous pouvez pousser votre image locale vers le registre de conteneurs.
Note

Pour que vous puissiez pousser une image Docker vers un référentiel de registre, il doit exister dans votre compartiment. Si le référentiel n'existe pas, la commande Docker push ne fonctionne pas correctement.
Note

La barre oblique dans un nom de référentiel ne représente pas une structure de répertoire hiérarchique. La valeur facultative <image-path-name> vous permet d'organiser vos référentiels.

Pousser votre image locale

Maintenant que vous avez créé votre image Docker locale, poussez-la vers le registre de conteneurs.

Procédez de la façon suivante.

Ouvrez votre session d'interface de ligne de commande OCI.
Connectez-vous au service de registre de conteneurs pour OCI :
```
docker login <region-key>.ocir.io
```
Vous êtes invité à entrer votre nom de connexion et votre mot de passe.
- Nom d'utilisateur : <tenancy-namespace>/<user-name>
- Mot de passe : <auth-token>
Listez vos images Docker locales :
```
docker images
```
Les images Docker de votre système s'affichent. Identifiez l'image que vous avez créée dans la dernière section : node-hello-app
Marquez votre image locale avec l'URL du registre plus le nom du référentiel, afin de pouvoir la pousser vers ce référentiel.
```
docker tag <your-local-image> <repo-url>/<repo-name>
```
- Remplacez <repo-url> par :
```
<region-key>.ocir.io/<tenancy-namespace>/
```
- Remplacez <repo-name> par :
  <image-folder-name>/<image-name> à la section Créer un référentiel Docker.
- Voici un exemple de ce que l'on obtient une fois les deux éléments combinés :
```
docker tag node-hello-app iad.ocir.io/my-namespace/node-apps/node-hello-app
```
  Dans cet exemple, les composants sont les suivants :
  - URL du référentiel : iad.ocir.io/my-namespace/
  - Nom du référentiel : node-apps/node-hello-app
Note

Le service de registre de conteneurs pour OCI prend désormais en charge la création d'un référentiel de registre dans n'importe quel compartiment et non plus uniquement dans le compartiment racine (location). Pour pousser l'image vers le référentiel que vous avez créé, combinez l'URL du registre au nom exact du référentiel. Le service de registre de conteneurs pour OCI établit une correspondance avec le nom de référentiel unique et pousse votre image.
Vérifiez vos images Docker pour voir si l'image a été copiée.
```
docker images
```
- L'image marquée porte le même ID image que votre image locale.
- Le nom de l'image marquée est le suivant :
```
<region-key>.ocir.io/<tenancy-namespace>/<image-path-name>/<image-name>
```

Poussez l'image vers le registre de conteneurs.

docker push <copied-image-name>:latest

Exemple :

docker push iad.ocir.io/my-namespace/node-apps/node-hello-app:latest

Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Conteneurs et artificiels, cliquez sur Container Registry.

Recherchez votre image dans le registre de conteneurs une fois la commande push terminée.

Déployer l'image

Maintenant que votre image a été poussée vers le registre de conteneurs, vous pouvez déployer votre image et votre application.

Créez une clé secrète de registre pour votre application. Cette clé secrète authentifiera votre image lorsque vous la déploierez dans votre grappe.
Pour créer votre clé secrète, complétez les informations de 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>'
```
Après avoir exécuté la commande, vous recevez un message semblable au suivant : secret/ocirsecret created.
Vérifiez que la clé secrète a été créée. Exécutez la commande suivante :
```
kubectl get secret ocirsecret --output=yaml
```
La sortie comprend des informations sur votre clé secrète et est affichée dans le format yaml.

Déterminez l'URL d'hôte de votre 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

Sur votre système, créez un fichier nommé node-app.yaml avec le texte suivant :

Remplacez les paramètres fictifs suivants :

<your-image-url>
<your-secret-name>

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

Déployez votre application à l'aide de la commande suivante .
```
kubectl create -f node-app.yaml
```
Sortie :
```
deployment.apps/node-app created
service/node-app-lb created
```
Note

Dans le fichier node-app.yaml, le code situé après les tirets ajoute un équilibreur de charge flexible.

Tester votre application

Une fois votre application déployée, le chargement de l'équilibreur de charge peut prendre quelques secondes.

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.
Note

En attendant que l'équilibreur de charge soit déployé, vous pouvez vérifier le statut de votre grappe à l'aide des commandes suivantes :
- Obtenir le statut de chaque pod : kubectl get pods
- Obtenir le statut de l'application : kubectl get deployment
Utilisez l'adresse IP de l'équilibreur de charge pour vous connecter à votre application dans un navigateur :
```
http://<load-balancer-IP-address>:3000
```
Voici ce qui s'affiche sur le navigateur : <h1>Hello World from Node.js!</h1>
Annulez le déploiement de votre application dans la grappe. ((Facultatif) Pour supprimer votre application, exécutez la commande suivante :
```
kubectl delete -f node-app.yaml
```
Sortie :
```
deployment.apps/node-app deleted
service "node-app-lb" deleted
```
Votre application est maintenant supprimée de votre grappe.

Étape suivante

Vous avez créé une application Hello World, vous l'avez déployée dans une grappe Kubernetes et vous l'avez rendue accessible sur Internet à l'aide du cadre Node Express.

Pour en savoir plus sur le développement à l'aide des produits Oracle, consultez les sites suivants :

Documentation sur Oracle Cloud Infrastructure

Kubernetes : Déployer une application Node Express

Étapes préliminaires

1. Préparer

2. Configurer une grappe

3. Créer une application locale

4. Déployer votre image Docker

Étape suivante