Kubernetes avec Cloud Shell : déploiement d'une application Flask Python

Dans ce tutoriel, vous utilisez un compte Oracle Cloud Infrastructure pour configurer un cluster Kubernetes. Ensuite, vous créez une application Python avec une structure Flask. Enfin, vous déployez l'application vers votre cluster à l'aide de Cloud Shell.

Les principales tâches expliquent comment :

  • créer un compartiment,
  • configurer un cluster Kubernetes sur OCI,
  • créer une application Python dans une structure Flask,
  • créer une image Docker,
  • propager l'image vers OCI Container Registry,
  • utiliser Cloud Shell pour 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 Python, dans une structure Flask, sur Oracle Cloud Infrastructure Kubernetes Engine à l'aide de Cloud Shell.

Pour plus d'informations, voir :

Avant de commencer

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

Exigences
  • Un compte Oracle Cloud Infrastructure payant. Reportez-vous à Inscription à Oracle Cloud Infrastructure.
  • Cloud Shell fournit les applications suivantes :
    • JDK 8+
    • Python 3.6.8+
    • Kubectl 1.18.10+
    • Apache Maven 3.5+
    • Docker 19.0.11+
Remarque

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.

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 nombre de coeurs disponibles :
      • 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 correspondant aux formes suivantes :
      • Nom de la limite : lb-flexible-bandwidth-count
      • Disponible : 1 au minimum.
Remarque

Ce tutoriel crée trois instances de calcul avec une forme VM.Standard.E2.1 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 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 sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option affichée.
      • 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>

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. Cliquez sur Créer une stratégie.
  6. Renseignez les informations suivantes :
    • Nom : manage-compartments
    • Description : Autoriser le groupe <groupe-auquel-le-nom-utilisateur-appartient> à répertorier, créer, mettre à jour, supprimer et récupérer des compartiments dans la location.
    • Compartiment : <your-tenancy>(root)
  7. Pour Générateur de stratégies, cliquez sur Afficher l'éditeur manuel.
  8. Collez la stratégie suivante :
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  9. Cliquez sur Créer.

Référencer

Le 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 le compartiment dans la liste Compartiment.
  3. Cliquez sur Créer une stratégie.
  4. Renseignez les informations suivantes :
    • Nom : gérer-ressources-de-<nom-du-compartiment>
    • 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érencer

Stratégies 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
    • Bande passante réseau : 1.0 (cette valeur est calculée en fonction du nombre d'OCPU.)
    • Nombre total maximal de cartes d'interface réseau virtuelles : 2 (cette valeur est calculée en fonction du nombre d'OCPU).
  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 Cloud Shell pour accéder au cluster

Après avoir créé un cluster Kubernetes, configurez Cloud Shell 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 à Cloud Shell. Suivez les étapes de la boîte de dialogue. Les étapes suivantes sont indiquées à titre de référence.
  6. Cliquez sur Lancer Cloud Shell. Vous pouvez également cliquer sur l'icône Cloud Shell (cloud-shell-icon) dans le menu principal et démarrer une session.
  7. Vérifiez la version de l'interface de ligne de commande oci et vérifiez que Cloud Shell fonctionne.
    oci -v
  8. Créez un fichier kubeconfig pour votre configuration. Utilisez les informations de la boîte de dialogue Accéder à votre cluster.
    oci ce cluster create-kubeconfig <use data from dialog>
    Le message suivant apparaît :
    New config written to the Kubeconfig file <your-home-directory>/.kube/config
    Remarque

    Si le fichier config n'est pas stocké à son emplacement par défaut (~/.kube/config), vous devez exporter la variable d'environnement KUBECONFIG pour pointer vers l'emplacement.
    export KUBECONFIG=$HOME/<new-location>/config
    Remarque

    Lorsque vous utilisez plusieurs clusters, indiquez un fichier de configuration spécifique sur la ligne de commande. Exemple :
    kubectl --kubeconfig=</path/to/config/file> <some-command>
  9. Testez la configuration du cluster à l'aide de la commande suivante.

    Répertoriez les clusters :

    kubectl get service

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

3. Création de votre application Docker

A présent, configurez la structure Flask sur Cloud Shell. Ensuite, créez et exécutez une application Python.

Création d'une application locale

Créez votre application Flask.

  1. Installez Flask.
    pip3 install --user Flask
  2. Créez un répertoire pour l'application.
    mkdir python-hello-app
  3. Changez de répertoire pour utiliser python-hello-app.
    cd python-hello-app
  4. Créez une application "Hello, World!".

    Créez le fichier :

    vi hello.py

    Dans le fichier, saisissez le texte suivant :

    from flask import Flask
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        return '<h1>Hello World from Flask!</h1>'
    
    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=int("5000"), debug=True)
  5. Enregistrez le fichier.
Exécution de l'application locale

Exécutez l'application Flask.

  1. Exécutez le programme Python.
    export FLASK_APP=hello.py
    export FLASK_ENV=development
    python3 hello.py

    La sortie suivante est générée :

    * Serving Flask app 'hello' (lazy loading)
    * Environment: development
    * Debug mode: on
    * Running on all addresses.
    WARNING: This is a development server. Do not use it in a production deployment.
    * Running on http://x.x.x.x:5000/ (Press CTRL+C to quit)
    * Restarting with stat
    * Debugger is active!
    * Debugger PIN: xxx-xxx-xxx                    
  2. Déplacez l'application en arrière-plan.
    • Appuyez sur Ctrl+Z.
    • Entrez la commande suivante : bg
  3. Testez l'application à l'aide de curl.
    Dans le terminal Cloud Shell, saisissez le code ci-dessous :
    curl -X GET http://localhost:5000

    Sortie :

    <h1>Hello World from Flask!</h1>
  4. Arrêtez l'application en cours d'exécution.
    • Lorsque vous avez terminé le test, obtenez l'ID de processus de l'application.
      ps -ef
    • Arrêtez le processus.
      kill <your-pid>

Vous avez créé une application Python locale avec la structure Flask.

Références :

Pour plus d'informations sur Flask, reportez-vous à la documentation Flask.

Création d'une image Docker

A présent, créez une image Docker pour l'application Flask.

  1. Assurez-vous d'abord que vous êtes dans le répertoire python-hello-app.
  2. Créez un fichier nommé Dockerfile :

    Créez le fichier :

    vi Dockerfile

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

    FROM python:3.9-slim-buster
    ADD hello.py /
    COPY . /app
    WORKDIR /app
    RUN pip3 install Flask
    EXPOSE 5000
    CMD [ "python3", "./hello.py" ]
  3. Créez une image Docker :
    docker build -t python-hello-app .

    Un message de succès s'affiche.

    [INFO] BUILD SUCCESS
    Successfully tagged python-hello-app:latest
  4. Exécutez l'image Docker :
    docker run --rm -p 5000:5000 python-hello-app:latest &
  5. Testez l'application à l'aide de la commande curl :
    curl -X GET http://localhost:5000
    Si vous recevez le message <h1>Hello World from Flask!</h1>, l'image Docker est en cours d'exécution. Vous pouvez désormais propager l'image vers Container Registry.
  6. Arrêtez l'application en cours d'exécution.
    • Lorsque vous avez terminé le test, obtenez l'ID de processus de l'application.
      ps -ef
    • Arrêtez le processus.
      kill <your-pid>
Félicitations ! Vous avez créé une image Docker Flask Python.

4. Déploiement de l'image Docker

L'image Python étant créée, vous pouvez maintenant la déployer.

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

    Exemple : flask-apps/python-hello-app

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

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

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

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

Suivez les étapes ci-après.

  1. Ouvrez une fenêtre de terminal.
  2. Connectez-vous à Container Registry :
    docker login <region-key>.ocir.io

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

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

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

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

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

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

      Dans cet exemple, les composants sont les suivants :

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

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

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

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

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

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

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

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

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

  3. Déterminez l'URL d'hôte de l'image de registre à l'aide du modèle suivant :
    <region-code>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>
    Exemple :
    iad.ocir.io/my-namespace/flask-apps/python-hello-app:latest
  4. Sur votre système, créez un fichier nommé 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: 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: 5000
              protocol: TCP
          imagePullSecrets:
            - name: <your-secret-name>
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: 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: 5000
      selector:
        app: app
  5. Déployez l'application avec la commande suivante.
    kubectl create -f app.yaml
    Sortie :
    deployment.apps/app created
    Remarque

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

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

    Remarque

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

    Le navigateur affiche : <h1>Hello World from Flask!</h1>

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

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

Etapes suivantes

Vous avez créé une application Python 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 Flask.

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