Kubernetes avec Cloud Shell : Déployer une application Python Flask

Dans ce tutoriel, vous utiliserez un compte Oracle Cloud Infrastructure pour configurer une grappe Kubernetes. Ensuite, vous créerez une application Python avec un cadre Flask. Enfin, vous déploierez votre application dans votre grappe à l'aide de Cloud Shell.

Voici les principales tâches :

  • Créer un compartiment.
  • Configurer une grappe Kubernetes sur OCI.
  • Créer une application Python dans un cadre Flask.
  • Créer une image Docker.
  • Pousser votre image vers le registre de conteneurs pour OCI.
  • Utiliser Cloud Shell pour déployer votre application Docker dans votre grappe.
  • Vous connecter à votre application à partir d'Internet.
Diagramme des composants nécessaires pour exécuter une application Python, dans un cadre Flask, sur Oracle Cloud Infrastructure Kubernetes Engine à l'aide de Cloud Shell.

Pour plus d'informations, voir :

Étapes préliminaires

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

Exigences
  • Un compte Oracle Cloud Infrastructure payant. Voir 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+
Note

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.

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 :
    • Filtrez les options suivantes :
      • Service : Régions
      • Portée : Location
      • Source : Nombre de régions abonnées
      • compartiment : <tenancy-name> (root)
    • Recherchez la limite de service :
      • Nom de la limite : subscribed-region-count
      • Limite de service : 2 au minimum
  4. Nombre de coeurs de calcul disponibles pour VM.Standard.E3. Forme flexible :
    • Filtrez les options suivantes :
      • Service : Calcul
      • Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
      • Ressource : Coeurs pour Standard.E3. Instances Flex et BM.Standard.E3.128
      • compartiment : <tenancy-name> (root)
    • Recherchez le nombre de coeurs disponibles :
      • Nom de la limite : standard-e3-core-ad-count
      • Disponible : 1 au moins
    • Répétez l'opération pour Portée : <second-availability-domain> et <third-availability-domain>. Chaque région doit comporter au moins un coeur disponible pour cette forme.
  5. Découvrez si vous disposez de 50 Go de volume par blocs disponibles :
    • Filtrez les options suivantes :
      • Service : Volume par blocs
      • Portée : <first-availability-domain>. Exemple : EMlr:US-ASHBURN-AD-1
      • Taille du volume de ressource (Go)
      • compartiment : <tenancy-name> (root)
    • Recherchez le nombre de coeurs disponibles :
      • 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 :
    • Filtrez les options suivantes :
      • Service : LbaaS
      • Portée : <your-region>. Exemple : us-ashburn-1
      • Source : <blank>
      • compartiment : <tenancy-name> (root)
    • Recherchez le nombre de formes suivantes
      • Nom de la limite : lb-flexible-bandwidth-count
      • Disponible : 1 au moins
Note

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

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

Note

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

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

Note

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

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

Créer un jeton d'autorisation
  1. Dans le menu de navigation , sélectionnez le menu Profil Icône du 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 le menu de navigation , sélectionnez le menu Profil Icône du menu Profil, puis sélectionnez Location : <your_tenancy_name>.
    • L'espace de noms de la location : <tenancy-namespace>
      • Dans le menu de navigation , sélectionnez le menu Profil Icône du menu Profil, puis sélectionnez Location : <your_tenancy_name>.
      • Copiez la valeur de Espace de noms du stockage d'objets.
      Note

      Pour certains comptes, le nom et l'espace de noms de la location sont différents. Veillez à utiliser l'espace de noms dans ce tutoriel.
    • OCID de la location : <tenancy-ocid>
      • Dans le menu de navigation , sélectionnez le menu Profil Icône du menu Profil, puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
      • Copier l'OCID.
    • Nom d'utilisateur : <user-name>
      • Dans le menu de navigation , sélectionnez le menu Profil Icône du menu Profil, puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
    • OCID d'utilisateur : <user-ocid>
      • Dans le menu de navigation , sélectionnez le menu Profil Icône du 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 : US East (Ashburn).
      • Recherchez l'identificateur de votre région dans le tableau de la région et domaine de disponibilité.
      • Exemple : us-ashburn-1.
    • Clé de région : <region-key>
  3. Cliquez sur le lien Créer un jeton d'authentification.
    • Jeton d'authentification : <auth-token>

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 le menu de navigation , sélectionnez le menu Profil Icône du menu Profil, puis sélectionnez Paramètres de l'utilisateur ou Mon profil, selon l'option que vous voyez.
  2. Dans le volet de gauche, cliquez sur Groupes.
  3. Dans un carnet, 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. Cliquez sur Créer une politique.
  6. Entrez les informations suivantes :
    • Name: manage-compartments
    • Description : Allow the group <the-group-your-username-belongs> to list, create, update, delete and recover compartments in the tenancy.
    • Compartiment : <your-tenancy>(root)
  7. Pour Générateur de politiques, cliquez sur Afficher l'éditeur manuel.
  8. Collez la politique suivante :
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  9. 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 : Compartment for <your-description>.
    • compartiment parent : <your-tenancy>(root)
  5. Cliquez sur Créer un compartiment.

Inférence : Créez un compartiment

Ajouter une politique de ressource

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

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

Avec ce privilège, vous pouvez gérer toutes les ressources de votre compartiment, ce qui vous confère essentiellement des droits administratifs sur 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 Compartiments.
  3. Cliquez sur Créer une politique.
  4. Entrez les informations suivantes :
    • Nom : manage-<your-compartment-name>-resources
    • Description : Allow users to list, create, update, and delete resources in <your-compartment-name>.
    • Compartiment : <your-tenancy>(root)
  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.

Informations de référence

Politiques communes

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

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

  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 Quick Create Cluster 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é d'API public

      La grappe Kubernetes sera hébergée dans un sous-réseau public avec une adresse IP publique affectée automatiquement.

    • Noeuds de travail Kubernetes : Noeuds de travail privés

      Les noeuds de travail Kubernetes seront hébergés dans un sous-réseau privé.

    • Forme : VM.Standard.E3.Flex
    • Sélectionner le nombre d'OCPU : 1
    • Quantité de mémoire (Go) : 16
    • Nombre de noeuds : 3
    • Bande passante de réseau : 1.0 (Cette valeur est calculée en fonction du nombre d'OCPU.)
    • Nombre total de cartes vNIC maximum : 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.

    • Définir une taille de volume de démarrage personnalisée : Cochez cette case.
    • Vérification d'image : Désélectionnez la case.
    • Ajouter une clé SSH : Aucune clé SSH.
  8. Cliquez sur Next (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 Cloud Shell pour accéder à votre grappe

Après avoir créé une grappe Kubernetes, configurez Cloud Shell 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 Cloud Shell. Suivez les étapes de la boîte de dialogue. Les étapes suivantes sont fournies pour référence.
  6. Cliquez sur Lancer Cloud Shell. Sinon, dans le menu principal, vous pouvez cliquer sur l'icône Cloud Shell (icône Cloud shell) et démarrer une session.
  7. Vérifiez la version de votre interface CLI oci et assurez-vous 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 grappe.
    oci ce cluster create-kubeconfig <use data from dialog>
    Vous obtenez le message suivant :
    New config written to the Kubeconfig file <your-home-directory>/.kube/config
    Note

    Si le fichier config n'est pas stocké dans 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
    Note

    Lorsque vous travaillez avec plusieurs grappes, vous spécifiez un fichier de configuration spécifique sur la ligne de commande. Exemple :
    kubectl --kubeconfig=</path/to/config/file> <some-command>
  9. Testez la configuration de votre grappe à l'aide de la commande suivante.

    Listez les grappes :

    kubectl get service

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

3. Créer votre application Docker

À présent, configurez le cadre Flask sur Cloud Shell. Ensuite, vous créerez et exécuterez une application Python.

Créer une application locale

Créez votre application Flask.

  1. Installez Flask.
    pip3 install --user Flask
  2. Créez un répertoire pour votre application.
    mkdir python-hello-app
  3. Accédez au répertoire python-hello-app.
    cd python-hello-app
  4. Créez une application "Hello, World!".

    Créez le fichier :

    vi hello.py

    Dans le fichier, entrez 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écuter l'application locale

Exécutez votre application Flask.

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

    Voici la sortie 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 à l'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, entrez le code suivant :
    curl -X GET http://localhost:5000

    Sortie :

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

Vous avez créé une application Python locale avec le cadre Flask.

Références :

Pour plus d'informations sur Flask, voir la documentation sur Flask.

Créer une image Docker

À présent, créez une image Docker pour votre application Flask.

  1. Assurez-vous 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 suivant dans le fichier et enregistrez celui-ci :

    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 .

    Vous obtenez un message de réussite.

    [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 <h1>Hello World from Flask!</h1> s'affiche, l'image Docker est en cours d'exécution. Vous pouvez maintenant pousser l'image vers le registre de conteneurs.
  6. Arrêtez l'application en cours d'exécution.
    • Une fois le test terminé, obtenez l'ID processus de votre application.
      ps -ef
    • Arrêtez le processus.
      kill <your-pid>
Félicitations! Vous avez créé une image Docker Python Flask.

4. Déployer votre image Docker

Maintenant que votre image Python est créée, vous pouvez la déployer.

Créer un référentiel Docker
  1. Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Conteneurs et artificiels, 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> = <image-path-name>/<image-name>

    Exemple : flask-apps/python-hello-app

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

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

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

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

Procédez de la façon suivante.

  1. Ouvrez une fenêtre de terminal.
  2. Connectez-vous au registre de conteneurs :
    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 :
    docker images

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

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

      <image-folder-name>/<image-name> à la section Créer un référentiel Docker.

    • Voici un exemple de ce que l'on obtient une fois les deux éléments combinés :
      docker tag python-hello-app iad.ocir.io/my-namespace/flask-apps/python-hello-app

      Dans cet exemple, les composants sont les suivants :

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

    Le service de registre de conteneurs pour OCI prend désormais en charge la création d'un référentiel de registre dans n'importe quel compartiment et non plus uniquement dans le compartiment racine (location). Pour pousser l'image vers le référentiel que vous avez créé, combinez l'URL du registre au nom exact du référentiel. Le service de registre de conteneurs pour OCI établit une correspondance avec le nom de référentiel unique et pousse votre image.
  5. Vérifiez vos images Docker pour voir si l'image a été copiée.
    docker images
    • La image marquée ou copiée a le même ID image que votre image locale.
    • Nom de l'image copiée :
      <region-key>.ocir.io/<tenancy-namespace>/<image-folder-name>/<image-name>
  6. Poussez l'image vers le registre de conteneurs.
    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éveloppement. Sous Conteneurs et artificiels, cliquez sur Container Registry.

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

Déployer l'image
Maintenant que votre image a été poussée vers le registre de conteneurs, vous pouvez déployer votre image et votre application.
  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-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 paramètres fictifs suivants :
    • <your-image-url>
    • <your-secret-name>
    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 votre application à l'aide de la commande suivante.
    kubectl create -f app.yaml
    Sortie :
    deployment.apps/app created
    Note

    Dans le fichier app.yaml, le code situé après les tirets ajoute un équilibreur de charge flexible.
Tester votre application
Une fois votre application déployée, le chargement de l'équilibreur de charge peut prendre quelques secondes.
  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.

    Note

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

    Voici ce qui s'affiche sur le navigateur : <h1>Hello World from Flask!</h1>

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

    Votre application est maintenant supprimée de votre grappe.

Étape suivante

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

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