Documentation Oracle Cloud Infrastructure

Kubernetes : déploiement d'une application Spring Boot

Dans ce tutoriel, vous utilisez un compte Oracle Cloud Infrastructure pour configurer un cluster Kubernetes. Ensuite, vous déployez une application Spring Boot 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 Spring Boot et une image Docker,
  • propager l'image vers OCI Container Registry,
  • déployer l'application Docker vers le cluster,
  • vous connecter à l'application à partir d'Internet.
Diagramme des composants nécessaires à l'exécution d'une application Spring Boot 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+
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 décrites dans les ressources suivantes :

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

Obtention des applications

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 du JDK
  1. Vérifiez l'installation en cours : 
    java -version
  2. Pour installer JDK 11, exécutez les commandes suivantes :
    • Oracle Linux : 
      sudo yum update
      yum list jdk*
      sudo yum install -y <jdk-version-of-your-choice>
    • Ubuntu :
      sudo apt update
      sudo apt install -y openjdk-11-jdk-headless
  3. Vérifiez l'installation. 
    java -version
  4. Définissez JAVA_HOME dans .bashrc.

    Mettez à jour le fichier :

    vi .bashrc

    Ajoutez le texte ci-dessous à la fin du fichier, puis enregistrez ce dernier :

    # set JAVA_HOME
export JAVA_HOME=<path-to-jdk>

    Exemples :

    # set JAVA_HOME in Oracle Linux
export JAVA_HOME=/usr/java/jdk-11.0.10 
    # set JAVA_HOME in Ubuntu
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
  5. Activez la commande précédente dans la fenêtre active. 
    source ~/.bashrc
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 d'Apache Maven
  1. Vérifiez l'installation en cours.
    mvn --version
  2. Pour installer Apache Maven, reportez-vous aux liens suivants :
  3. Vérifiez l'installation. 
    mvn --version
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
  1. Avec Git, créez une copie du guide pour Spring Boot avec Docker : 
    git clone https://github.com/spring-guides/gs-spring-boot-docker.git
  2. Changez de répertoire pour utiliser gs-spring-boot-docker/initial. 
    cd gs-spring-boot-docker/initial
  3. Changez de répertoire pour utiliser le répertoire source Java src/main/java/hello. 
    cd src/main/java/hello
  4. Mettez à jour Application.java avec le code suivant : 
    package hello;
                        
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {
	
	@RequestMapping("/")
	public String home() {
		return "<h1>Spring Boot Hello World!</h1>";
	}

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

}
  5. Enregistrez le fichier.
Exécution de l'application locale
  1. Changez de répertoire pour utiliser gs-spring-boot-docker/initial.
  2. Packagez l'application : 
    mvn package
    Exemple de sortie :
    [INFO] Replacing main artifact with repackaged archive
[INFO] BUILD SUCCESS
  3. Exécutez l'application : 
    java -jar target/spring-boot-docker-0.0.1-SNAPSHOT.jar

    Exemple de sortie :

      .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (vx.x.x)

hello.Application: Started Application in x seconds (JVM running for x.x)
  4. Continuez à exécuter le code et testez l'application de l'une des manières suivantes :
    • Dans un nouveau terminal connecté à l'instance, saisissez le code ci-dessous :
      curl -X GET http://localhost:8080

      Sortie :

      <h1>Spring Boot Hello World!</h1>
    • Chargez l'adresse suivante dans un navigateur :
      localhost:8080

      Vous pouvez utiliser la deuxième option uniquement si l'environnement est local.

  5. Arrêtez l'application en cours d'exécution. Exemple : Ctrl + C
Création d'une image Docker
Une image Docker contient une application, ses dépendances et les instructions permettant d'exécuter l'application.
Remarque

Pour macOS, vous pouvez enlever sudo dans les commandes docker.
  1. Changez de répertoire pour utiliser gs-spring-boot-docker/initial.
  2. Créez un fichier nommé Dockerfile. 
    FROM openjdk:8-jdk
RUN addgroup --system spring && adduser --system spring -ingroup spring
USER spring:spring
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]
  3. Créez l'image Docker : 
    sudo docker build -t spring-boot-hello .

    Exemple de sortie :

    Successfully built xxxxxxxxxxxx
Successfully tagged spring-boot-hello:latest
  4. Exécutez l'image Docker : 
    sudo docker run -p 8080:8080 -t spring-boot-hello

    Vous obtenez le même résultat qu'en exécutant l'application locale.

  5. Arrêtez l'application en cours d'exécution.
Félicitations ! Vous avez créé une image Docker Spring Boot.
Références :

4. Déploiement de l'image Docker

Propagez l'image Docker Spring Boot 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> = <repo-prefix>/<image-name>

    Exemple : spring-projects/spring-boot-hello

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

    Avant de propager une image vers un compartiment, vous devez créer un référentiel dans ce compartiment.
    Remarque

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

Pour macOS, vous pouvez enlever sudo dans les commandes docker.
  1. Ouvrez une fenêtre de terminal.
  2. Connectez-vous à OCI Container Registry : 
    sudo 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 : 
    sudo docker images

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

  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. 
    sudo docker tag <your-local-image> <repo-url>/<repo-name>
    • Remplacez l'URL de référentiel et le nom de référentiel <repo-url>/<repo-name> par ce qui suit : 
      <region-key>.ocir.io/<tenancy-namespace>/<repo-name>
    • Remplacer <repo-name> par ce qui suit :

      <repo-prefix>/<image-name> dans la section Création d'un référentiel Docker.

    • Exemple :
      sudo docker tag spring-boot-hello iad.ocir.io/my-namespace/spring-projects/spring-boot-hello

      Dans cet exemple, les composants sont les suivants :

      • <repo-url>: iad.ocir.io/my-namespace/
      • <repo-name>: spring-projects/spring-boot-hello
    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 balisée. 
    sudo docker images
    • L'image balisée pointe vers l'image locale et a le même ID que l'image locale.
    • Le nom de l'image balisée est le suivant :
      <region-key>.ocir.io/<tenancy-namespace>/<repo-prefix>/<image-name>
  6. Propagez l'image vers Container Registry. 
    sudo docker push <tagged-image-name>:latest
    Exemple :
    sudo docker push iad.ocir.io/my-namespace/spring-projects/spring-boot-hello:latest
  7. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Conteneurs et artefacts, cliquez sur Registre du conteneur.
  8. Recherchez votre image dans Container Registry une fois la commande push terminée.
Remarque

Vous pouvez propager uniquement des images dont le nom inclut l'URL de registre.
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-prefix>/<image-name>:<tag>
    Exemple :
    iad.ocir.io/my-namespace/spring-projects/spring-boot-hello:latest
  4. Sur votre système, créez un fichier nommé sb-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: sbapp
spec:
  selector:
    matchLabels:
      app: sbapp
  replicas: 3
  template:
    metadata:
      labels:
        app: sbapp
    spec:
      containers:
      - name: sbapp
        image: <your-image-url>
        imagePullPolicy: Always
        ports:
        - name: sbapp
          containerPort: 8080
          protocol: TCP
      imagePullSecrets:
        - name: <your-secret-name>
---
apiVersion: v1
kind: Service
metadata:
  name: sbapp-lb
  labels:
    app: sbapp
  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: 8080
  selector:
    app: sbapp
  5. Déployez l'application avec la commande suivante. 
    kubectl create -f sb-app.yaml
    Sortie :
    deployment.apps/sbapp created
    Remarque

    Dans le fichier sb-app.yaml, le code après les tirets ajoute un équilibreur de charge.
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 publique soit affectée à l'équilibreur de charge.

  2. Utilisez l'adresse IP de l'équilibreur de charge pour vous connecter à l'application dans un navigateur : 
    http://<load-balancer-IP-address>:8080

    Le navigateur affiche : Spring Boot Hello World!

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

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

Etapes suivantes

Félicitations ! 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 Spring Boot.

Pour obtenir plus d'informations sur le développement avec les produits Oracle, consultez les sites suivants :