Documentation sur Oracle Cloud Infrastructure

Kubernetes : Déployer une application Spring Boot

Dans ce tutoriel, vous utiliserez un compte Oracle Cloud Infrastructure pour configurer une grappe Kubernetes. Ensuite, vous déploierez une application Spring Boot 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 Spring Boot et une image Docker.
  • Pousser l'image vers le registre de conteneurs pour OCI.
  • Déployer l'application Docker dans votre grappe.
  • Vous connecter à votre application à partir d'Internet.
Diagramme des composants nécessaires pour exécuter une application Spring Boot 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 Container Registry, Kubernetes et les équilibreurs de charge :
  • Pour créer des applications et des images Docker :
    • L'un des environnements locaux suivants :
    • 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+
Note

Si vous ne souhaitez pas configurer les applications requises dans votre environnement local, vous pouvez utiliser Cloud Shell pour Oracle Cloud Infrastructure à la place. Avec Cloud Shell, tous les outils nécessaires pour gérer votre application sont déjà installés et prêts à l'emploi, ce qui présente un certain avantage. Effectuez les étapes décrites dans :

Kubernetes avec Cloud Shell : Déployer une application Spring Boot

Obtenir les applications

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
  • Installez une machine virtuelle Linux avec une forme de calcul de type Toujours gratuit sur Oracle Cloud Infrastructure. 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
      • Suivez les sections 2 et 3.
      • Si vous disposez d'un compte payant, pour la section 2, sélectionnez des 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.
      • Pour mettre à jour les paramètres du pare-feu, effectuez l'étape 8 de la section 4.
Installer JDK
  1. Vérifiez votre installation courante : 
    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

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

    # 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 courante. 
    source ~/.bashrc
Installer Python 3 et Pip 3
  1. Vérifiez votre installation courante.
    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
Installer le client Kubernetes
  1. 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"...
  2. Pour installer le client kubectl, consultez les liens suivants :
  3. Vérifiez l'installation. 
    kubectl version --client
Installer Apache Maven
  1. Vérifiez votre installation courante.
    mvn --version
  2. Pour installer Apache Maven, consultez les liens suivants :
  3. Vérifiez l'installation. 
    mvn --version
Installer Docker
  1. Vérifiez votre installation courante : 
    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

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

  3. Ubuntu Linux

    Pour installer Docker sur Ubuntu Linux, consultez le lien suivant : Obtenir Docker

  4. 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
  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. Déterminez votre limite de service pour Régions :
    • Définissez un filtre pour les options suivantes :
      • Service : Régions
      • Portée : Location
      • Ressource : Nombre de régions abonnées
      • compartiment : <tenancy-name> (racine)
    • Recherchez la limite de service :
      • Nom de la limite : subscribed-region-count
      • Limite de service : 2 au minimum
  4. Déterminez le nombre de coeurs de calcul disponibles pour la forme VM.Standard.E3.Flex :
    • Définissez un filtre pour les options suivantes :
      • Service : Calcul
      • Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
      • Ressource : Coeurs pour Standard.E3.Flex et les instances 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 : <second-availability-domain> et <third-availability-domain>. Chaque région doit comporter au moins un coeur disponible pour cette forme.
  5. Déterminez si vous disposez de 50 Go de volume par blocs disponibles :
    • Définissez un filtre pour 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> (racine)
    • 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.
  6. Déterminez le nombre d'équilibreurs de charge flexibles dont vous disposez :
    • Définissez un filtre pour les options suivantes :
      • Service : LbaaS
      • Portée : <your-region>. Exemple : us-ashburn-1
      • Source : <blank>
      • compartiment : <tenancy-name> (racine)
    • Déterminez le nombre d'équilibreurs de charge flexibles disponibles :
      • Nom de la limite : lb-flexible-count
      • Disponible : 1 au minimum
Note

Ce tutoriel crée trois instances de calcul avec une forme VM.Standard.E3.Flex 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.

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 Mbits/s ou Bande passante de 400 Mbits/s.

Créer un jeton d'autorisation
  1. Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon 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.
Note

Enregistrez votre jeton juste après l'avoir créé. Vous ne pourrez plus y accéder ultérieurement.
Collecter les informations requises
  1. Collectez les informations de données d'identification suivantes à partir de la console Oracle Cloud Infrastructure.
    • Nom de la location : <tenancy-name>
      • Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Location : <your_tenancy_name>.
    • espace de noms de la location : <tenancy-namespace>
      • Dans la barre 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 la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Location : <your_tenancy_name>.
      • Copier l'OCID.
    • Nom d'utilisateur : <user-name>
      • Dans la barre 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 la barre 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.
  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 : États-Unis - Est (Ashburn).
      • Recherchez l'identificateur de votre région dans le tableau de la rubrique Régions et domaines de disponibilité.
      • Exemple : us-ashburn-1.
    • Clé de région : <region-key>
  3. Copiez le jeton d'authentification obtenu à la section 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.

  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 chemins :
    • Exemple pour Linux : /home/ubuntu/.local/bin/virtualenvwrapper.sh
    • Exemple pour MacOS : /usr/local/bin/virtualenvwrapper.sh
  4. 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.

  5. 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
  1. Démarrez un environnement virtuel.
    workon cli-app
  2. 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:~$

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

    Si tout est configuré correctement, la version s'affiche.

    oci --help
Configurer l'interface CLI OCI
  1. Entrez la commande suivante dans votre environnement virtuel :
    oci setup config
  2. Entrez vos réponses obtenues à la section Collecter les informations requises :
    • Emplacement de votre configuration [$HOME/.oci/config] : <utiliser la valeur par défaut>
    • OCID d'utilisateur : <user-ocid>
    • OCID de la location : <tenancy-ocid>
    • Région (par exemple, us-ashburn-1) : <region-identifier>
  3. Entrez les informations suivantes pour configurer vos clés de chiffrement d'API OpenSSL :
    • Générer une nouvelle paire de clés RSA de signature d'API? [O/n]: O
    • Répertoire de vos clés [$HOME/.oci] : <utiliser la valeur par défaut>
    • Nom de votre clé [oci_api_key] <utiliser la valeur par défaut>
  4. 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.
  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 d'utilisateur :
    • Allez à la console.
    • Dans la barre 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é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.
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
  1. Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
  2. Dans l'onglet de gauche, cliquez sur Groupes.
  3. Dans un bloc-notes, copiez le nom de groupe auquel appartient votre nom d'utilisateur.
  4. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Politiques.
  5. Sélectionnez votre compartiment dans la liste déroulante Compartiments.
  6. Cliquez sur Créer une politique.
  7. Entrez 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 politiques, cliquez sur Afficher l'éditeur manuel.
  9. Collez la politique suivante :
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  10. Cliquez sur Créer.

Informations de référence : Type de ressource compartments dans Informations détaillées sur les combinaisons Verbes + Type de ressource pour GIA

Créer 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. Entrez les informations suivantes :
    • Nom : <your-compartment-name>
    • Description : Compartiment pour <your-description>.
    • Compartiment parent : <your-tenancy>(root)
  5. Cliquez sur Créer un compartiment.

Informations de référence : Créer 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, qui vous accorde essentiellement des droits administratifs sur le compartiment, vous pouvez gérer toutes les ressources contenues dans celui-ci.

Étapes d'ajout de la politique
  1. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Politiques.
  2. Sélectionnez votre compartiment dans la liste déroulante Compartiments.
  3. Cliquez sur Créer une politique.
  4. Entrez les informations suivantes :
    • Nom : manage-<your-compartment-name>-resources
    • Description : Autoriser les utilisateurs à lister, créer, mettre à jour et supprimer des ressources dans <your-compartment-name>.
    • Compartiment : <your-tenancy>(root)
  5. 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)
  6. Cliquez sur Créer.

Inférence : Service de 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".

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

    La boîte de dialogue Création rapide de grappe s'affiche.

  6. 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é 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
  7. Cliquez sur Afficher les options avancées.

    Conservez les valeurs par défaut.

    • Indiquer 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
  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 une grappe.

    Les services configurés pour votre grappe s'affichent.

  10. Cliquez sur Fermer.
  11. 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.

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

    Les informations sur votre grappe s'affichent.

  4. Cliquez sur Accéder à la grappe.
  5. Cliquez sur Accès local.
  6. 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 nouvel interpréteur de commandes, ajoutez export KUBECONFIG=$HOME/.kube/config à votre fichier ~/.bashrc.
  7. 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
  1. Faites une copie du guide Spring Boot avec Docker à l'aide de Git : 
    git clone https://github.com/spring-guides/gs-spring-boot-docker.git
  2. Accédez au répertoire gs-spring-boot-docker/initial. 
    cd gs-spring-boot-docker/initial
  3. Accédez au 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écuter l'application locale
  1. Accédez au répertoire gs-spring-boot-docker/initial.
  2. Encapsulez 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. Conservez le code en cours d'exécution et testez l'application en procédant de l'une des façons suivantes :
    • Dans un nouveau terminal connecté à votre instance, entrez le code suivant :
      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 seconde option, seulement si votre environnement est local.

  5. Arrêtez l'application en cours d'exécution. Exemple : Ctrl + C
Créer une image Docker
Une image Docker contient une application, ses dépendances, et des instructions d'exécution de l'application.
Note

Pour MacOS, vous pouvez supprimer sudo dans les commandes docker.
  1. Accédez au répertoire 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 que pour l'exécution de 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éployer votre image Docker

Poussez votre image Docker Spring Boot vers le registre de conteneurs pour OCI. Utilisez ensuite l'image pour déployer votre application.

Créer un référentiel Docker
  1. Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Conteneurs et artefacts, cliquez sur Container Registry.
  2. Dans le panneau de navigation de gauche, sélectionnez <your-compartment-name>.
  3. Cliquez sur Créer un référentiel.
  4. Créez un référentiel privé avec le nom de votre choix : 
    <repo-name> = <repo-prefix>/<image-name>

    Exemple : spring-projects/spring-boot-hello

    À présent, vous pouvez pousser votre image locale vers le registre de conteneurs.
    Note

    Avant de pousser une image dans un compartiment, vous devez créer un référentiel dans celui-ci.
    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 <repo-prefix> vous permet d'organiser vos référentiels.
Pousser votre image locale
Note

Pour MacOS, vous pouvez supprimer sudo dans les commandes docker.
  1. Ouvrez une fenêtre de terminal.
  2. Connectez-vous au service de registre de conteneurs pour OCI : 
    sudo 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>
  3. Listez vos images Docker locales : 
    sudo docker images

    Les images Docker de votre système s'affichent. Identifiez l'image que vous avez créée dans la dernière section : spring-boot-hello

  4. 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. 
    sudo docker tag <your-local-image> <repo-url>/<repo-name>
    • Remplacez <repo-url>/<repo-name> par : 
      <region-key>.ocir.io/<tenancy-namespace>/<repo-name>
    • Remplacer <repo-name> par :

      Valeurs <repo-prefix>/<image-name>, obtenues à la section Créer 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
    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.
  5. Vérifiez vos images Docker pour voir si l'image a été marquée. 
    sudo docker images
    • L'image marquée pointe vers votre image locale et porte le même ID image que celle-ci.
    • Le nom de l'image marquée est le suivant :
      <region-key>.ocir.io/<tenancy-namespace>/<repo-prefix>/<image-name>
  6. Poussez l'image vers le registre de conteneurs. 
    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éveloppement. Sous Conteneurs et artefacts, cliquez sur Container Registry.
  8. Recherchez votre image dans le registre de conteneurs une fois la commande push terminée.
Note

Vous ne pouvez pousser que les images dont le nom comprend l'URL du registre.
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.
  1. 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.

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

  3. Déterminez l'URL de l'hôte de votre 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 paramètres fictifs suivants :
    • <your-image-url>
    • <your-secret-name>
    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 votre application à l'aide de la commande suivante. 
    kubectl create -f sb-app.yaml
    Sortie :
    deployment.apps/sbapp created
    Note

    Dans le fichier sb-app.yaml, le code situé après les tirets ajoute un équilibreur de charge.
Tester votre application
Une fois votre 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 à votre application dans un navigateur : 
    http://<load-balancer-IP-address>:8080

    Voici ce qui s'affiche sur le navigateur : Spring Boot Hello World!

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

    Votre application est maintenant supprimée de votre grappe.

Étape suivante

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

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