Développer une application Kubernetes pour la base de données Azure SQL

  • Article

S’applique à Azure SQL Database

Dans ce tutoriel, découvrez comment développer une application moderne à l’aide de Python, des conteneurs Docker, de Kubernetes et de la base de données Azure SQL.

Le développement d’applications modernes présente plusieurs défis. De la sélection d’une « pile » de font-end au stockage et au traitement des données à partir de plusieurs normes concurrentes, en passant par la garantie des plus hauts niveaux de sécurité et de performances, les développeurs sont tenus de s’assurer que les applications se mettent à l’échelle et fonctionnent correctement, et qu’elles sont prises en charge sur plusieurs plateformes. Pour cette dernière exigence, regrouper l’application dans des technologies de conteneurs comme Docker et déployer plusieurs conteneurs sur la plateforme Kubernetes est désormais de rigueur dans le développement d’applications.

Dans cet exemple, nous explorons l’utilisation de Python, des conteneurs Docker et de Kubernetes, qui s’exécutent tous sur la plateforme Microsoft Azure. L’utilisation de Kubernetes signifie que vous avez également la possibilité d’utiliser des environnements locaux ou même d’autres clouds pour un déploiement transparent et cohérent de votre application, et permet des déploiements multiclouds pour encore plus de résilience. Nous allons également utiliser Microsoft Azure SQL Database pour un environnement basé sur les services, évolutif, hautement résilient et sécurisé pour le stockage et le traitement des données. En réalité, dans de nombreux cas, d’autres applications utilisent déjà souvent Microsoft Azure SQL Database, et cet exemple d’application peut servir à utiliser et enrichir ces données.

Cet exemple est assez complet, mais il utilise l’application, la base de données et le déploiement les plus simples pour illustrer le processus. Vous pouvez adapter cet exemple pour qu’il soit beaucoup plus robuste, même en utilisant les dernières technologies pour les données retournées. Il s’agit d’un outil pédagogique utile pour créer un modèle pour d’autres applications.

Utiliser Python, les conteneurs Docker, Kubernetes et l’exemple de base de données AdventureWorksLT dans un exemple pratique

La société AdventureWorks (fictive) utilise une base de données qui stocke des données sur les ventes et le marketing, les produits, les clients et la fabrication. Elle contient également des vues et des procédures stockées qui joignent des informations sur les produits, comme le nom, la catégorie et le prix du produit ainsi qu’une brève description.

L’équipe de développement d’AdventureWorks souhaite créer une preuve de concept (PoC) qui retourne des données à partir d’une vue dans la base de données AdventureWorksLT, et les rendre disponibles en tant qu’API REST. À l’aide de cette PoC, l’équipe de développement crée une application plus évolutive et multicloud prête pour l’équipe chargée des ventes. L’équipe a sélectionné la plateforme Microsoft Azure pour tous les aspects du déploiement. La PoC utilise les éléments suivants :

  • Une application Python utilisant le package Flask pour le déploiement web sans périphérique de contrôle.
  • Des conteneurs Docker pour l’isolation du code et de l’environnement, stockés dans un registre privé afin que toute la société puisse réutiliser les conteneurs d’applications dans les projets futurs, économiser du temps et de l’argent.
  • Kubernetes pour faciliter le déploiement et la mise à l’échelle, et pour éviter le verrouillage de la plateforme.
  • Microsoft Azure SQL Database pour la sélection de la taille, des performances, de la mise à l’échelle, de l’autogestion et de la sauvegarde, en plus du stockage et du traitement des données relationnelles au niveau de sécurité le plus élevé.

Dans cet article, nous expliquons le processus de création de l’ensemble du projet de preuve de concept. Les étapes générales de création de l’application sont les suivantes :

  1. Configurer les prérequis
  2. Créer l’application
  3. Créer un conteneur Docker pour déployer l’application et tester
  4. Créer un registre Azure Container Service (ACS) et charger le conteneur dans le registre ACS
  5. Créer l’environnement Azure Kubernetes Service (AKS)
  6. Déployer le conteneur d’application à partir du registre ACS sur AKS
  7. Tester l’application
  8. Nettoyer

Prérequis

Tout au long de cet article, vous devez remplacer plusieurs valeurs. Vérifiez que vous remplacez régulièrement ces valeurs pour chaque étape. Vous pouvez ouvrir un éditeur de texte et supprimer ces valeurs pour définir les valeurs correctes au fur et à mesure que vous travaillez sur le projet de preuve de concept :

  • ReplaceWith_AzureSubscriptionName : remplacez cette valeur par le nom de votre abonnement Azure.
  • ReplaceWith_PoCResourceGroupName : remplacez cette valeur par le nom du groupe de ressources que vous souhaitez créer.
  • ReplaceWith_AzureSQLDBServerName : remplacez cette valeur par le nom du serveur logique de la base de données Azure SQL que vous créez à l’aide du Portail Azure.
  • ReplaceWith_AzureSQLDBSQLServerLoginName : remplacez cette valeur par la valeur du nom d’utilisateur SQL Server que vous créez dans le Portail Azure.
  • ReplaceWith_AzureSQLDBSQLServerLoginPassword : remplacez cette valeur par la valeur du mot de passe de l’utilisateur SQL Server que vous créez dans le Portail Azure.
  • ReplaceWith_AzureSQLDBDatabaseName : remplacez cette valeur par le nom de la base de données Azure SQL que vous créez à l’aide du Portail Azure.
  • ReplaceWith_AzureContainerRegistryName : remplacez cette valeur par le nom de l’Azure Container Registry que vous souhaitez créer.
  • ReplaceWith_AzureKubernetesServiceName : remplacez cette valeur par le nom de l’Azure Kubernetes Service que vous souhaitez créer.

Les développeurs d’AdventureWorks utilisent un mélange de systèmes Windows, Linux et Apple pour le développement, de sorte qu’ils utilisent Visual Studio Code comme environnement et git pour le contrôle de code source, qui exécutent tous deux une multiplateforme.

Pour la PoC, l’équipe requiert les conditions préalables suivantes :

  1. Python, pip et packages : l’équipe de développement choisit le langage de programmation Python comme standard pour cette application web. Actuellement, l’équipe utilise la version 3.9, mais toute version prenant en charge les packages requis pour la PoC est acceptable.

  2. L’équipe utilise le package pyodbc pour accéder à la base de données.

  3. L’équipe utilise le package ConfigParser pour contrôler et définir des variables de configuration.

  4. L’équipe utilise le package Flask pour l’interface web de l’application.

  5. Ensuite, l’équipe installe l’outil Azure CLI, facilement identifié par la syntaxe az. Cet outil multiplateforme permet une approche en ligne de commande et en script de la PoC, afin que l’équipe puisse répéter les étapes à mesure qu’elle apporte des modifications et des améliorations.

  6. Une fois l’outil Azure CLI configuré, l’équipe se connecte à son abonnement Azure et définit le nom de l’abonnement utilisé pour la PoC. Elle vérifie ensuite que le serveur et la base de données Azure SQL Database sont accessibles dans l’abonnement :

    az login
az account set --name "ReplaceWith_AzureSubscriptionName"
az sql server list
az sql db list ReplaceWith_AzureSQLDBDatabaseName

  7. Un groupe de ressources Microsoft Azure est un conteneur logique qui contient les ressources associées d’une solution Azure. En règle générale, les ressources qui partagent le même cycle de vie sont ajoutées dans le même groupe de ressources afin de pouvoir facilement les déployer, les mettre à jour et les supprimer en tant que groupe. Le groupe de ressources stocke des métadonnées concernant les ressources, et vous pouvez spécifier un emplacement pour le groupe de ressources.

    Des groupes de ressources peuvent être créés et gérés à l’aide du Portail Azure ou d’Azure CLI. Ils peuvent également être utilisés pour regrouper les ressources associées d’une application et les diviser en groupes pour la production et la non-production, ou toute autre structure organisationnelle que vous préférez.

    Screenshot from the Azure portal showing how to search for and filter for Azure Resource groups.

    Dans l’extrait de code suivant, vous pouvez voir la commande az utilisée pour créer un groupe de ressources. Dans notre exemple, nous utilisons la région eastusd’Azure.

    az group create --name ReplaceWith_PoCResourceGroupName --location eastus

  8. L’équipe de développement crée une base de données Azure SQL sur laquelle l’exemple de base de données AdventureWorksLT est installé, à l’aide d’une connexion authentifiée SQL.

    AdventureWorks a normalisé la plateforme du système de gestion de base de données relationnelle Microsoft SQL Server et l’équipe de développement souhaite utiliser un service géré pour la base de données plutôt que de l’installer localement. L’utilisation de la base de données Azure SQL permet à ce service géré d’être entièrement compatible avec le code, quel que soit l’environnement d’exécution du moteur SQL Server : local, dans un conteneur, dans Linux ou Windows, ou même dans un environnement Internet des objets (IoT).

    1. Lors de la création, l’équipe a utilisé le Portail de gestion Azure pour définir le pare-feu de l’application sur l’ordinateur de développement local, et modifié la valeur par défaut que vous voyez ici pour activer Autoriser tous les services Azure, mais aussi récupéré les identifiants de connexion.

      Screenshot from the Azure portal showing the Create SQL Database page. On the Networking tab, for Connectivity method, the Public endpoint option is selected. The Add current client IP Address option is Yes.

      Avec cette approche, la base de données peut être accessible dans une autre région ou même dans le cadre d’un autre abonnement.

    2. L’équipe a configuré une connexion authentifiée SQL pour le test, mais réexaminera cette décision au cours d’une révision de sécurité.

    3. L’équipe a utilisé l’exemple de base de données AdventureWorksLT pour la PoC en utilisant le même groupe de ressources de la PoC. Ne vous inquiétez pas, à la fin de ce tutoriel, nous nettoierons toutes les ressources de ce nouveau groupe de ressources de la PoC.

    4. Vous pouvez utiliser le Portail Azure pour déployer la base de données Azure SQL. Lors de la création de la base de données Azure SQL, dans l’onglet Paramètres supplémentaires, pour l’option Utiliser les données existantes, sélectionnez Exemple.

      Screenshot from the Azure portal showing the Create SQL Database page. In the Additional settings tab, for the Use existing data option, select Sample.

    5. Enfin, dans l’onglet Balises de la nouvelle base de données Azure SQL, l’équipe de développement a fourni des métadonnées de balises pour cette ressource Azure, comme Propriétaire, ServiceClass ou WorkloadName.

Créer l’application

Ensuite, l’équipe de développement a créé une application Python simple qui ouvre une connexion à la base de données Azure SQL et retourne une liste de produits. Ce code sera remplacé par des fonctions plus complexes et peut également inclure plusieurs applications déployées dans les pods Kubernetes en production pour une approche robuste orientée manifest des solutions d’applications.

  1. L’équipe a créé un fichier texte simple appelé .env dans le but de contenir des variables pour les connexions du serveur et d’autres informations. À l’aide de la bibliothèque python-dotenv, l’équipe peut ensuite séparer les variables du code Python. Il s’agit d’une approche courante pour conserver les secrets et d’autres informations en dehors du code lui-même.

    SQL_SERVER_ENDPOINT = ReplaceWith_AzureSQLDBServerName
SQL_SERVER_USERNAME = ReplaceWith_AzureSQLDBSQLServerLoginName
SQL_SERVER_PASSWORD = ReplaceWith_AzureSQLDBSQLServerLoginPassword
SQL_SERVER_DATABASE = ReplaceWith_AzureSQLDBDatabaseName

    Attention

    Pour plus de clarté et de simplicité, cette application utilise un fichier de configuration lu à partir de Python. Étant donné que le code est déployé avec le conteneur, les informations de connexion peuvent être dérivées du contenu. Vous devez examiner attentivement les différentes méthodes d’utilisation de la sécurité, des connexions et des secrets, et déterminer le meilleur niveau et le meilleur mécanisme à utiliser pour notre application. Choisissez toujours le niveau de sécurité le plus élevé, et même plusieurs niveaux pour assurer la sécurité de votre application. Vous disposez de plusieurs options pour utiliser des informations secrètes, comme des chaînes de connexion et des options similaires, et la liste suivante présente quelques-unes de ces options.

    Pour plus d’informations, consultez Sécurité des bases de données Azure SQL.

  2. L’équipe a ensuite écrit l’application de la PoC et l’a appelée app.py.

    Le script suivant effectue les étapes suivantes :

    1. Configurer les bibliothèques pour les interfaces web de configuration et de base.
    2. Charger les variables à partir du fichier .env.
    3. Créer l’application Flask-RESTful.
    4. Accéder aux informations de connexion de base de données Azure SQL à l’aide des valeurs du fichier config.ini.
    5. Créer une connexion à la base de données Azure SQL à l’aide des valeurs du fichier config.ini.
    6. Se connecter à la base de données Azure SQL à l’aide du package pyodbc.
    7. Créer la requête SQL à exécuter sur la base de données.
    8. Créer la classe qui sera utilisée pour retourner les données de l’API.
    9. Définir le point de terminaison d’API sur la classe Products.
    10. Enfin, démarrer l’application sur le port Flask par défaut 5000.
    # Set up the libraries for the configuration and base web interfaces
from dotenv import load_dotenv
from flask import Flask
from flask_restful import Resource, Api
import pyodbc

# Load the variables from the .env file
load_dotenv()

# Create the Flask-RESTful Application
app = Flask(__name__)
api = Api(app)

# Get to Azure SQL Database connection information using the config.ini file values
server_name = os.getenv('SQL_SERVER_ENDPOINT')
database_name = os.getenv('SQL_SERVER_DATABASE')
user_name = os.getenv('SQL_SERVER_USERNAME')
password = os.getenv('SQL_SERVER_PASSWORD')

# Create connection to Azure SQL Database using the config.ini file values
ServerName = config.get('Connection', 'SQL_SERVER_ENDPOINT')
DatabaseName = config.get('Connection', 'SQL_SERVER_DATABASE')
UserName = config.get('Connection', 'SQL_SERVER_USERNAME')
PasswordValue = config.get('Connection', 'SQL_SERVER_PASSWORD')

# Connect to Azure SQL Database using the pyodbc package
# Note: You may need to install the ODBC driver if it is not already there. You can find that at:
# https://learn.microsoft.com/sql/connect/odbc/download-odbc-driver-for-sql-server
connection = pyodbc.connect(f'Driver=ODBC Driver 17 for SQL Server;Server={ServerName};Database={DatabaseName};uid={UserName};pwd={PasswordValue}')

# Create the SQL query to run against the database
def query_db():
    cursor = connection.cursor()
    cursor.execute("SELECT TOP (10) [ProductID], [Name], [Description] FROM [SalesLT].[vProductAndDescription] WHERE Culture = 'EN' FOR JSON AUTO;")
    result = cursor.fetchone()
    cursor.close()
    return result

# Create the class that will be used to return the data from the API
class Products(Resource):
    def get(self):
        result = query_db()
        json_result = {} if (result == None) else json.loads(result[0])     
        return json_result, 200

# Set the API endpoint to the Products class
api.add_resource(Products, '/products')

# Start App on default Flask port 5000
if __name__ == "__main__":
    app.run(debug=True)

  3. L’équipe a vérifié que cette application s’exécutait localement et renvoyait une page vers http://localhost:5000/products.

    Screenshot from a web browser of the Flask return page.

    Important

    Lors de la génération d’applications de production, n’utilisez pas le compte Administrateur pour accéder à la base de données. Pour plus d’informations, découvrez comment configurer un compte pour votre application. Le code de cet article est simplifié pour vous permettre de commencer rapidement à utiliser des applications à l’aide de Python et Kubernetes dans Azure.

    De façon plus réaliste, vous pouvez utiliser un utilisateur de base de données autonome avec des autorisations en lecture seule, ou un utilisateur de connexion ou de base de données autonome connecté à une identité managée affectée par l’utilisateur avec des autorisations en lecture seule.

    Pour plus d’informations, consultez un exemple complet sur la création d’une API avec Python et la base de données Azure SQL.

Déployer l’application sur un conteneur Docker

Un conteneur est un espace réservé et protégé dans un système informatique qui fournit l’isolation et l’encapsulation. Pour créer un conteneur, utilisez un fichier manifeste, c’est-à-dire un simple fichier texte décrivant les fichiers binaires et le code que vous souhaitez contenir. À l’aide d’un runtime de conteneur (comme Docker), vous pouvez ensuite créer une image binaire contenant tous les fichiers que vous souhaitez exécuter et référencer. À partir de là, vous pouvez « exécuter » l’image binaire, c’est-à-dire un conteneur, que vous pouvez référencer comme s’il s’agissait d’un système informatique complet. Il s’agit d’un moyen plus simple, et de moindre envergure, d’extraire les runtimes et l’environnement de votre application que d’utiliser une machine virtuelle complète. Pour plus d’informations, consultez Conteneurs et Docker.

L’équipe a commencé par un DockerFile (le manifest) qui superpose en différentes couches les éléments de ce qu’elle souhaite utiliser. Elle commence par une image Python de base sur laquelle les bibliothèques pyodbc sont déjà installées, puis exécute toutes les commandes nécessaires pour contenir le programme et le fichier config de l’étape précédente.

Le fichier Dockerfile suivant comporte les étapes suivantes :

  1. Commencer par un fichier binaire de conteneur sur lequel Python et pyodbc sont déjà installés.
  2. Créer un répertoire de travail pour l’application.
  3. Copier tout le code du répertoire actif dans le WORKDIR.
  4. Installer les bibliothèques nécessaires.
  5. Une fois le conteneur démarré, exécuter l’application et ouvrir tous les ports TCP/IP.
# syntax=docker/dockerfile:1

# Start with a Container binary that already has Python and pyodbc installed
FROM laudio/pyodbc

# Create a Working directory for the application
WORKDIR /flask2sql

# Copy all of the code from the current directory into the WORKDIR
COPY . .

# Install the libraries that are required
RUN pip install -r ./requirements.txt

# Once the container starts, run the application, and open all TCP/IP ports 
CMD ["python3", "-m" , "flask", "run", "--host=0.0.0.0"]

Avec ce fichier en place, l’équipe a déposé une invite de commandes dans le répertoire de codage et exécuté le code suivant pour créer l’image binaire à partir du manifest, puis une autre commande pour démarrer le conteneur :

docker build -t flask2sql .
docker run -d -p 5000:5000 -t flask2sql

Une fois de plus, l’équipe teste le lien http://localhost:5000/products pour s’assurer que le conteneur peut accéder à la base de données, et elle obtient le résultat suivant :

Screenshot from a web browser of the Flask return page from the Container.

Déployer l’image dans un registre Docker

Le conteneur fonctionne maintenant, mais n’est disponible que sur l’ordinateur du développeur. L’équipe de développement souhaite rendre cette image d’application disponible pour le reste de l’entreprise, puis sur Kubernetes pour le déploiement de production.

La zone de stockage des images conteneurs est appelée référentiel. Il peut y avoir des référentiels publics et privés pour les images conteneurs. En fait, AdvenureWorks a utilisé une image publique pour l’environnement Python dans son Dockerfile.

L’équipe souhaite contrôler l’accès à l’image, et plutôt que de la placer sur le web, elle décide de l’héberger elle-même, mais dans Microsoft Azure où elle dispose d’un contrôle total sur la sécurité et l’accès. Vous pouvez en savoir plus sur Microsoft Azure Container Registry ici.

En revenant à la ligne de commande, l’équipe de développement utilise az CLI pour ajouter un service de registre de conteneurs, activer un compte d’administration, le définir sur des « tirages » anonymes pendant la phase de test et définir un contexte de connexion sur le registre :

az acr create --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureContainerRegistryName --sku Standard
az acr update -n ReplaceWith_AzureContainerRegistryName --admin-enabled true
az acr update --name ReplaceWith_AzureContainerRegistryName --anonymous-pull-enabled
az acr login --name ReplaceWith_AzureContainerRegistryName

Ce contexte sera utilisé dans les étapes suivantes.

Ajouter une balise à l’image Docker locale pour la préparer au téléchargement

L’étape suivante consiste à envoyer l’image conteneur d’application locale au service Azure Container Registry (ACR) afin qu’elle soit disponible dans le cloud.

  1. Dans l’exemple de script suivant, l’équipe utilise les commandes Docker pour répertorier les images sur l’ordinateur.
  2. Elle utilise l’utilitaire az CLI pour répertorier les images dans le service ACR.
  3. Elle utilise la commande Docker pour « ajouter une balise à » l’image avec le nom de destination de l’ACR qu’elle a créé à l’étape précédente, et pour définir un numéro de version pour le DevOps approprié.
  4. Enfin, elle répertorie à nouveau les informations de l’image locale pour s’assurer que la balise s’est bien appliquée.
docker images
az acr list --resource-group ReplaceWith_PoCResourceGroupName --query "[].{acrLoginServer:loginServer}" --output table
docker tag flask2sql ReplaceWith_AzureContainerRegistryName.azurecr.io/azure-flask2sql:v1
docker images

Une fois le code écrit et testé, le Dockerfile, l’image et le conteneur exécutés et testés, le service ACR configuré et toutes les balises appliquées, l’équipe peut télécharger l’image sur le service ACR.

Elle utilise la commande Docker « push » pour envoyer le fichier, puis l’utilitaire az CLI pour s’assurer que l’image a été chargée :

docker push ReplaceWith_AzureContainerRegistryName.azurecr.io/azure-flask2sql:v1
az acr repository list --name ReplaceWith_AzureContainerRegistryName --output table

Déployer sur Kubernetes

L’équipe pourrait simplement exécuter des conteneurs et déployer l’application dans des environnements locaux et dans le cloud. Toutefois, elle souhaite ajouter plusieurs copies de l’application pour la mise à l’échelle et la disponibilité, ajouter d’autres conteneurs effectuant différentes tâches et ajouter la surveillance et l’instrumentation à l’ensemble de la solution.

Pour regrouper des conteneurs en une solution complète, l’équipe a décidé d’utiliser Kubernetes. Kubernetes s’exécute localement et sur toutes les principales plateformes cloud. Microsoft Azure dispose d’un environnement managé complet pour Kubernetes, appelé Azure Kubernetes Service (AKS). Apprenez-en plus sur AKS en consultant la Présentation de Kubernetes sur le parcours de formation Azure.

À l’aide de l’utilitaire az CLI, l’équipe ajoute AKS au même groupe de ressources qu’elle a créé précédemment. Avec une seule commande az, l’équipe de développement effectue les étapes suivantes :

  • Ajouter deux « nœuds » ou environnements informatiques pour la résilience dans la phase de test
  • Générer automatiquement des clés SSH pour accéder à l’environnement
  • Attacher le service ACR que l’équipe a créé lors des étapes précédentes afin que le groupement AKS puisse localiser les images qu’elle souhaite utiliser pour le déploiement
az aks create --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureKubernetesServiceName --node-count 2 --generate-ssh-keys --attach-acr ReplaceWith_AzureContainerRegistryName

Kubernetes utilise un outil en ligne de commande pour accéder à un groupement, appelé kubectl, et le contrôler. L’équipe utilise l’utilitaire az CLI pour télécharger l’outil kubectl et l’installer :

az aks install-cli

Étant donné que l’équipe dispose d’une connexion à AKS pour le moment, elle peut lui demander d’envoyer les clés SSH pour la connexion à utiliser lorsqu’elle exécute l’utilitaire kubectl :

az aks get-credentials --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureKubernetesServiceName

Ces clés sont stockées dans un fichier appelé .config dans le répertoire de l’utilisateur. Une fois le contexte de sécurité défini, l’équipe utilise kubectl get nodes pour afficher les nœuds du groupement :

kubectl get nodes

À présent, l’équipe utilise l’outil az CLI pour répertorier les images dans le service ACR :

az acr list --resource-group ReplaceWith_PoCResourceGroupName --query "[].{acrLoginServer:loginServer}" --output table

À présent, l’équipe peut générer le manifest que Kubernetes utilise pour contrôler le déploiement. Il s’agit d’un fichier texte stocké au format yaml. Voici le texte annoté dans le fichier flask2sql.yaml :

apiVersion: apps/v1
# The type of commands that will be sent, along with the name of the deployment
kind: Deployment
metadata:
  name: flask2sql
# This section sets the general specifications for the application
spec:
  replicas: 1
  selector:
    matchLabels:
      app: flask2sql
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
  minReadySeconds: 5 
  template:
    metadata:
      labels:
        app: flask2sql
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
# This section sets the location of the Image(s) in the deployment, and where to find them 
      containers:
      - name: flask2sql
        image:  bwoodyflask2sqlacr.azurecr.io/azure-flask2sql:v1
# Recall that the Flask application uses (by default) TCIP/IP port 5000 for access. This line tells Kubernetes that this "pod" uses that address.
        ports:
        - containerPort: 5000
---
apiVersion: v1
# This is the front-end of the application access, called a "Load Balancer"
kind: Service
metadata:
  name: flask2sql
spec:
  type: LoadBalancer
# this final step then sets the outside exposed port of the service to TCP/IP port 80, but maps it internally to the app's port of 5000
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5000
  selector:
    app: flask2sql

Une fois le fichier flask2sql.yaml défini, l’équipe peut déployer l’application sur le groupement AKS en cours d’exécution. Pour cela, il convient d’utiliser la commande kubectl apply, qui, comme vous le savez, a toujours un contexte de sécurité pour le groupement. Ensuite, la commande kubectl get service est envoyée pour surveiller le groupement à mesure qu’il est généré.

kubectl apply -f flask2sql.yaml
kubectl get service flask2sql --watch

Après quelques instants, la commande « watch » renvoie une adresse IP externe. À ce stade, l’équipe appuie sur CTRL-C pour interrompre la commande watch et enregistre l’adresse IP externe de l’équilibreur de charge.

Test de l’application

À l’aide de l’adresse IP (point de terminaison) obtenue à la dernière étape, l’équipe vérifie que la sortie est la même que celle de l’application locale et du conteneur :

Screenshot from a web browser of the Flask return page when finally testing the container. The output is the same as before.

Nettoyage

Une fois l’application créée, modifiée, documentée et testée, l’équipe peut désormais « supprimer » l’application. En conservant tout dans un seul groupe de ressources dans Microsoft Azure, il suffit de supprimer le groupe de ressources de la PoC à l’aide de l’utilitaire az CLI :

az group delete -n ReplaceWith_PoCResourceGroupName -y

Remarque

Si vous avez créé votre base de données Azure SQL dans un autre groupe de ressources et que vous n’en avez plus besoin, vous pouvez utiliser le Portail Azure pour le supprimer.

Le membre de l’équipe qui dirige le projet de la PoC utilise Microsoft Windows comme station de travail et souhaite conserver le fichier de secrets de Kubernetes, mais le supprimer du système comme emplacement actif. Il peut simplement copier le fichier dans un fichier texte config.old, puis le supprimer :

copy c:\users\ReplaceWith_YourUserName\.kube\config c:\users\ReplaceWith_YourUserName\.kube\config.old
del c:\users\ReplaceWith_YourUserName\.kube\config

Contenu connexe