Desarrollo de una aplicación de Kubernetes para Azure SQL Database

Se aplica a:Azure SQL Database

En este tutorial, aprenderá a desarrollar una aplicación moderna mediante Python, contenedores de Docker, Kubernetes y Azure SQL Database.

El desarrollo de aplicaciones modernas tiene varios desafíos. Desde seleccionar una "pila" de front-end a través del almacenamiento de datos y el procesamiento de varios estándares competidores, a través de garantizar los niveles más altos de seguridad y rendimiento, los desarrolladores deben asegurarse de que la aplicación se escala y funciona bien y es compatible con varias plataformas. Para este último requisito, agrupar la aplicación en tecnologías de contenedores como Docker e implementar varios contenedores en la plataforma Kubernetes es ahora de rigor en el desarrollo de aplicaciones.

En este ejemplo, se explora el uso de Python, contenedores de Docker y Kubernetes, que se ejecutan en la plataforma Microsoft Azure. El uso de Kubernetes significa que también tiene la flexibilidad de usar entornos locales o incluso otras nubes para una implementación sin problemas y coherente de la aplicación, y permite implementaciones multinube para lograr una mayor resistencia. También usaremos Microsoft Azure SQL Database para un entorno seguro y escalable basado en servicios para el almacenamiento y el procesamiento de datos. De hecho, en muchos casos, otras aplicaciones suelen usar Microsoft Azure SQL Database y esta aplicación de ejemplo se puede usar para usar y enriquecer aún más esos datos.

Este ejemplo es bastante completo en el ámbito, pero usa la aplicación, la base de datos y la implementación más sencillas para ilustrar el proceso. Puede adaptar este ejemplo para que sea mucho más sólido, incluso mediante el uso de las tecnologías más recientes para los datos devueltos. Es una herramienta de aprendizaje útil para crear un patrón para otras aplicaciones.

Uso de Python, contenedores de Docker, Kubernetes y la base de datos de ejemplo AdventureWorksLT en un ejemplo práctico

La empresa AdventureWorks (ficticia) usa una base de datos que almacena datos sobre ventas y marketing, productos, clientes y fabricación. También contiene vistas y procedimientos almacenados que unen información sobre los productos, como el nombre del producto, la categoría, el precio y una breve descripción.

El equipo de desarrollo de AdventureWorks quiere crear una prueba de concepto (PoC) que devuelva datos de una vista en la base de datos AdventureWorksLT y que estén disponibles como una API de REST. Con esta PoC, el equipo de desarrollo creará una aplicación más escalable y lista para varias nubes para el equipo de ventas. Han seleccionado la plataforma Microsoft Azure para todos los aspectos de la implementación. La PoC usa los siguientes elementos:

• Una aplicación de Python que usa el paquete flask para la implementación web sin interfaz.
• Contenedores de Docker para el aislamiento de código y entorno, almacenados en un registro privado para que toda la empresa pueda reutilizar los contenedores de aplicaciones en proyectos futuros, ahorrando tiempo y dinero.
• Kubernetes para facilitar la implementación y el escalado, y para evitar el bloqueo de la plataforma.
• Microsoft Azure SQL Database para seleccionar el tamaño, el rendimiento, la escala, la administración automática y la copia de seguridad, además del almacenamiento y el procesamiento de datos relacionales en el nivel de seguridad más alto.

En este artículo se explica el proceso para crear todo el proyecto de prueba de concepto. Los pasos generales para crear la aplicación son:

1. Configurar los requisitos previos
2. Crear la aplicación
3. Creación de un contenedor de Docker para implementar la aplicación y probar
4. Creación de un registro de Azure Container Service (ACS) y carga del contenedor en el registro de ACS
5. Crear el entorno Azure Kubernetes Service (AKS)
6. Implementación del contenedor de aplicaciones desde el Registro de ACS en AKS
7. Prueba de la aplicación
8. Limpieza

Requisitos previos

A lo largo de este artículo, hay varios valores que debe reemplazar. Asegúrese de reemplazar de forma coherente estos valores para cada paso. Es posible que desee abrir un editor de texto y quitar estos valores en para establecer los valores correctos a medida que trabaje a través del proyecto de prueba de concepto:

• ReplaceWith_AzureSubscriptionName: sustituya este valor por el nombre de la suscripción a Azure que tenga.
• ReplaceWith_PoCResourceGroupName: sustituya este valor por el nombre del grupo de recursos que desea crear.
• ReplaceWith_AzureSQLDBServerName: reemplace este valor por el nombre del servidor lógico de Azure SQL Database que cree mediante Azure Portal.
• ReplaceWith_AzureSQLDBSQLServerLoginName: reemplace este valor por el valor del nombre de usuario de SQL Server que cree en Azure Portal.
• ReplaceWith_AzureSQLDBSQLServerLoginPassword: reemplace este valor por el valor de la contraseña de usuario de SQL Server que cree en Azure Portal.
• ReplaceWith_AzureSQLDBDatabaseName: reemplace este valor por el nombre de Azure SQL Database que cree mediante Azure Portal.
• ReplaceWith_AzureContainerRegistryName: reemplace este valor por el nombre de Azure Container Registry que desea crear.
• ReplaceWith_AzureKubernetesServiceName: reemplace este valor por el nombre de Azure Kubernetes Service que desea crear.

Los desarrolladores de AdventureWorks usan una combinación de sistemas Windows, Linux y Apple para el desarrollo, por lo que usan Visual Studio Code como su entorno y Git para el control de código fuente, ambos que se ejecutan entre plataformas.

Para la PoC, el equipo requiere los siguientes requisitos previos:

1. Python, pip y paquetes: el equipo de desarrollo elige el lenguaje de programación Python como estándar para esta aplicación basada en web. Actualmente usan la versión 3.9, pero cualquier versión compatible con los paquetes requeridos de PoC es aceptable.

   • Puede descargar Python versión 3.9 desde python.org.

2. El equipo usa el paquete pyodbc para el acceso a la base de datos.

   • Puede instalar el paquete pyodbc con comandos pip.
   • Es posible que también necesite el software Microsoft ODBC Driver si aún no lo tiene instalado.

3. El equipo usa el paquete ConfigParser para controlar y establecer variables de configuración.

   • Puede instalar el paquete configparser con comandos pip.

4. El equipo usa el paquete flask para una interfaz web para la aplicación.

   • Puede instalar la versión de Python de la biblioteca de Flask.

5. A continuación, el equipo instaló la herramienta de la CLI de Azure, que se identifica fácilmente con la sintaxis az. Esta herramienta multiplataforma permite un enfoque de línea de comandos y secuencias de comandos para la PoC, de modo que puedan repetir los pasos a medida que realizan cambios y mejoras.

   • Puede descargar e instalar la herramienta de la CLI de Azure.

6. Con la CLI de Azure configurada, el equipo inicia sesión en su suscripción de Azure y establece el nombre de la suscripción que usó para la PoC. A continuación, se aseguraron de que el servidor Azure SQL Database y la base de datos son accesibles a la suscripción:

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

7. Un grupo de recursos de Microsoft Azure es un contenedor lógico que alberga recursos relacionados para una solución Azure. Por lo general, los recursos que comparten el mismo ciclo de vida se añaden al mismo grupo de recursos para que pueda implementarlos, actualizarlos y eliminarlos fácilmente como grupo. El grupo de recursos almacena metadatos sobre los recursos y puede especificar una ubicación para el grupo de recursos.

   Los grupos de recursos pueden crearse y gestionarse utilizando el portal Azure o la CLI de Azure. También se pueden usar para agrupar recursos relacionados para una aplicación y dividirlos en grupos para producción y no producción, o cualquier otra estructura organizativa que prefiera.

   

   En el siguiente fragmento de código, puede ver el comando az usado para crear un grupo de recursos. En nuestro ejemplo, usamos la región eastusde Azure.

   az group create --name ReplaceWith_PoCResourceGroupName --location eastus
   

8. Equipo de desarrollo crea una instancia de Azure SQL Database con la base de datos de ejemplo AdventureWorksLT instalada mediante un inicio de sesión autenticado de SQL.

   AdventureWorks se ha estandarizado en la plataforma del sistema de administración de bases de datos relacionales de Microsoft SQL Server y el equipo de desarrollo quiere usar un servicio administrado para la base de datos en lugar de instalar localmente. El uso de Azure SQL Database permite que este servicio administrado sea totalmente compatible con el código donde ejecute el motor de SQL Server: local, en un contenedor, en Linux o Windows, o incluso en un entorno de Internet de las cosas (IoT).

   1. Durante la creación, usaron el Portal de administración de Azure para establecer el firewall de la aplicación en la máquina de desarrollo local y cambiaron el valor predeterminado que ve aquí para habilitar Permitir todos los servicios de Azure y también recuperaron las credenciales de conexión.

      

      Con este enfoque, la base de datos podría ser accesible en otra región o incluso en una suscripción diferente.

   2. El equipo configuró un inicio de sesión autenticado de SQL para las pruebas, pero volverá a consultar esta decisión en una revisión de seguridad.

   3. El equipo usó la base de datos de ejemplo AdventureWorksLT para la PoC con el mismo grupo de recursos de PoC. No se preocupe, al final de este tutorial, limpiaremos todos los recursos de este nuevo grupo de recursos de PoC.

   4. Puede usar el portal Azure para implementar la base de datos de Azure SQL. Al crear Azure SQL Database, en la pestaña Configuración adicional, en la opción Usar datos existentes, seleccione Ejemplo.

      

   5. Por último, en la pestaña Etiquetas de la nueva base de datos de Azure SQL, el equipo de desarrollo proporcionó metadatos de etiquetas para este recurso de Azure, como Owner o ServiceClass o WorkloadName.

Crear la aplicación

A continuación, el equipo de desarrollo creó una aplicación de Python sencilla que abre una conexión a Azure SQL Database y devuelve una lista de productos. Este código se reemplazará por funciones más complejas y también podría incluir más de una aplicación implementada en los pods de Kubernetes en producción para un enfoque sólido basado en manifiestos para soluciones de aplicaciones.

1. El equipo creó un archivo de texto simple llamado .env para contener variables para las conexiones del servidor y otra información. Con la biblioteca python-dotenv, pueden separar las variables del código de Python. Este es un enfoque común para mantener secretos y otra información fuera del propio código.

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

   Precaución

   Para mayor claridad y simplicidad, esta aplicación usa un archivo de configuración que se lee desde Python. Dado que el código se implementará con el contenedor, es posible que la información de conexión pueda derivar del contenido. Debe tener en cuenta cuidadosamente los distintos métodos de trabajo con seguridad, conexiones y secretos y determinar el mejor nivel y mecanismo que debe usar para nuestra aplicación. Elija siempre el nivel más alto de seguridad e incluso varios niveles para asegurarse de que la aplicación sea segura. Tiene varias opciones de trabajar con información secreta, como cadena de conexión y similares, y en la lista siguiente se muestran algunas de esas opciones.

   Para obtener más información, consulte Seguridad de la base de datos de Azure SQL.

   • Otro método para trabajar con secretos en Python es usar la biblioteca python-secrets.
   • Revise la seguridad y los secretos de Docker.
   • Revise los secretos de Kubernetes.
   • También puede obtener más información sobre la autenticación de Microsoft Entra (anteriormente Azure Active Directory).

2. El equipo escribió la aplicación PoC y la llamó app.py.

   El siguiente script realiza estos pasos:

   1. Configure las bibliotecas para la configuración y las interfaces web base.
   2. Cargue las variables desde el archivo .env.
   3. Cree la aplicación Flask-RESTful.
   4. Acceda a la información de conexión de Azure SQL Database mediante los valores de archivo config.ini.
   5. Cree una conexión a Azure SQL Database mediante los valores de archivo config.ini.
   6. Conéctese a la base de datos de Azure SQL utilizando el paquete pyodbc.
   7. Cree la consulta SQL que se ejecutará en la base de datos.
   8. Cree la clase que se usará para devolver los datos de la API.
   9. Establezca el punto de conexión de API en la clase Products.
   10. Por último, inicie la aplicación en el puerto predeterminado de Flask 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. Comprobaron que esta aplicación se ejecuta localmente y devuelve una página a http://localhost:5000/products.

   

   Importante

   Al compilar aplicaciones de producción, no use la cuenta de administrador para acceder a la base de datos. Para obtener más información, lea más sobre cómo configurar una cuenta para la aplicación. El código de este artículo se simplifica para que pueda empezar a trabajar rápidamente con aplicaciones mediante Python y Kubernetes en Azure.

   De forma más realista, podría usar un usuario de base de datos independiente con permisos de solo lectura, o un usuario de base de datos independiente o de inicio de sesión conectado a una identidad administrada asignada por el usuario con permisos de solo lectura.

   Para más información, consulte un ejemplo completo sobre cómo crear una API con Python y Azure SQL Database.

Implementación de la aplicación en un contenedor de Docker

Un contenedor es un espacio reservado y protegido en un sistema informático que proporciona aislamiento y encapsulación. Para crear un contenedor, use un archivo de manifiesto, que es simplemente un archivo de texto que describe los archivos binarios y el código que desea contener. Con un entorno de ejecución de contenedor (como Docker), puede crear una imagen binaria que tenga todos los archivos que desea ejecutar y hacer referencia. Desde allí, puede "ejecutar" la imagen binaria y se denomina contenedor, a la que puede hacer referencia como si fuera un sistema informático completo. Es una manera más pequeña y sencilla de abstraer los entornos de ejecución y los entornos de la aplicación que el uso de una máquina virtual completa. Para obtener más información, consulte Contenedores y Docker.

El equipo comenzó con un DockerFile (el manifiesto) que agrupa en capas los elementos de lo que el equipo quiere usar. Comienzan con una imagen base de Python que ya tiene instaladas las bibliotecas pyodbc y, a continuación, ejecutan todos los comandos necesarios para contener el archivo de configuración y el programa en el paso anterior.

El Dockerfile siguiente tiene los pasos siguientes:

1. Comience con un binario contenedor que ya tenga Python e pyodbc instalado.
2. Cree un directorio de trabajo para la aplicación.
3. Copie todo el código del directorio actual en WORKDIR.
4. Instale las bibliotecas necesarias.
5. Una vez iniciado el contenedor, ejecute la aplicación y abra todos los puertos 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"]

Con ese archivo en su lugar, el equipo se quitó a un símbolo del sistema en el directorio de codificación y ejecutó el código siguiente para crear la imagen binaria desde el manifiesto y, a continuación, otro comando para iniciar el contenedor:

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

Una vez más, el equipo prueba el vínculo http://localhost:5000/products para asegurarse de que el contenedor puede acceder a la base de datos y ve la siguiente devolución:

Implementación de la imagen en un registro de Docker

El contenedor funciona ahora, pero solo está disponible en la máquina del desarrollador. El equipo de desarrollo quiere que esta imagen de aplicación esté disponible para el resto de la empresa y, a continuación, en Kubernetes para la implementación de producción.

El área de almacenamiento para Imágenes de contenedor se denomina repositorio y puede haber repositorios públicos y privados para imágenes de contenedor. De hecho, AdvenureWorks usó una imagen pública para el entorno de Python en su Dockerfile.

El equipo quiere controlar el acceso a la imagen y, en lugar de colocarlo en la web, decide que quiere hospedarlo a sí mismo, pero en Microsoft Azure donde tienen control total sobre la seguridad y el acceso. Puede obtener más información sobre Microsoft Azure Container Registry aquí.

Al volver a la línea de comandos, el equipo de desarrollo usa az CLI para agregar un servicio Container Registry, habilitar una cuenta de administración, establecerla en "pulls" anónimas durante la fase de prueba y establecer un contexto de inicio de sesión en el registro:

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

Este contexto se usará en los pasos posteriores.

Etiquetar la imagen de Docker local para prepararla para cargarla

El siguiente paso es enviar la imagen de contenedor de la aplicación local al servicio Azure Container Registry (ACR) para que esté disponible en la nube.

1. En el siguiente script de ejemplo, el equipo usa los comandos de Docker para enumerar las imágenes del equipo.
2. Usan la utilidad az CLI para enumerar las imágenes en el servicio ACR.
3. Usan el comando de Docker para "etiquetar" la imagen con el nombre de destino del ACR que crearon en el paso anterior y para establecer un número de versión para DevOps adecuado.
4. Por último, vuelven a enumerar la información de imagen local para asegurarse de que la etiqueta se ha aplicado correctamente.

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

Con el código escrito y probado, el Dockerfile, la imagen y el contenedor se ejecutan y prueban, el servicio ACR configurado y todas las etiquetas aplicadas, el equipo puede cargar la imagen en el servicio ACR.

Usan el comando "push" de Docker para enviar el archivo y, a continuación, la utilidad az CLI para asegurarse de que la imagen se cargó:

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

Implementación en Kubernetes

El equipo simplemente podría ejecutar contenedores e implementar la aplicación en entornos locales y en la nube. Sin embargo, les gustaría agregar varias copias de la aplicación para la escala y disponibilidad, agregar otros contenedores que realizan diferentes tareas y agregar supervisión e instrumentación a toda la solución.

Para agrupar contenedores en una solución completa, el equipo decidió usar Kubernetes. Kubernetes se ejecuta de forma local y en todas las principales plataformas en la nube. Microsoft Azure tiene un entorno administrado completo para Kubernetes, denominado Azure Kubernetes Service (AKS). Obtenga más información sobre AKS con la ruta de aprendizaje Introducción a Kubernetes en Azure.

Con la utilidad az CLI, el equipo agrega AKS al mismo grupo de recursos que creó anteriormente. Con un solo comando az, el equipo de desarrollo realiza los pasos siguientes:

• Adición de dos "nodos" o entornos informáticos para la resistencia en la fase de prueba
• Generación automática de claves SSH para el acceso al entorno
• Adjunte el servicio ACR que creó en los pasos anteriores para que el clúster de AKS pueda localizar las imágenes que desea usar para la implementación.

az aks create --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureKubernetesServiceName --node-count 2 --generate-ssh-keys --attach-acr ReplaceWith_AzureContainerRegistryName

Kubernetes usa una herramienta de línea de comandos para acceder a un clúster y controlarlo, denominado kubectl. El equipo usa la utilidad az CLI para descargar la herramienta kubectl e instalarla:

az aks install-cli

Dado que tienen una conexión a AKS en este momento, pueden pedirle que envíe las claves SSH para que se usen cuando ejecuten la utilidad kubectl:

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

Estas claves se almacenan en un archivo denominado .config en el directorio del usuario. Con ese conjunto de contexto de seguridad, el equipo usa kubectl get nodes para mostrar los nodos del clúster:

kubectl get nodes

Ahora el equipo usa la herramienta az CLI para enumerar las imágenes en el servicio ACR:

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

Ahora pueden compilar el manifiesto que Kubernetes usa para controlar la implementación. Se trata de un archivo de texto almacenado en formato yaml. Este es el texto anotado en el archivo 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

Con el archivo definido flask2sql.yaml, el equipo puede implementar la aplicación en el clúster de AKS en ejecución. Esto se hace con el comando kubectl apply, que a medida que se recuerda todavía tiene un contexto de seguridad para el clúster. A continuación, el comando kubectl get service se envía para ver el clúster a medida que se compila.

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

Después de unos instantes, el comando "watch" devolverá una dirección IP externa. En ese momento, el equipo presiona CTRL-C para interrumpir el comando de inspección y registra la dirección IP externa del equilibrador de carga.

Prueba de la aplicación

Con la dirección IP (punto de conexión) que obtuvo en el último paso, el equipo comprueba la misma salida que la aplicación local y el contenedor de Docker:

Limpiar

Con la aplicación creada, editada, documentada y probada, el equipo ahora puede "anular" la aplicación. Al mantener todo en un único grupo de recursos de Microsoft Azure, es una cuestión sencilla de eliminar el grupo de recursos de PoC mediante la utilidad az CLI:

az group delete -n ReplaceWith_PoCResourceGroupName -y

Nota:

Si creó la instancia de Azure SQL Database en otro grupo de recursos y ya no la necesita, puede usar Azure Portal para eliminarla.

El miembro del equipo que dirige el proyecto de PoC usa Microsoft Windows como estación de trabajo y quiere conservar el archivo de secretos de Kubernetes, pero quitarlo del sistema como ubicación activa. Simplemente pueden copiar el archivo en un archivo de texto config.old y eliminarlo:

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

Contenido relacionado

• Introducción al desarrollo de aplicaciones: SQL Database e Instancia administrada de SQL
• Conexión a Azure SQL Database y consulta mediante Python y el controlador pyodbc
• Publicación de un Project de base de datos para Azure SQL Database en el emulador local
• Examinar ejemplos de código para la base de datos de Azure SQL