Compartilhar via

Desenvolver um aplicativo Kubernetes para o Banco de Dados SQL do Azure

  • Artigo

Aplica-se a: Banco de Dados SQL do Azure

Neste tutorial, aprenda como desenvolver um aplicativo moderno usando Python, contêineres do Docker, Kubernetes e Banco de Dados SQL do Azure.

O desenvolvimento de aplicativos modernos tem vários desafios. Desde a seleção de uma "pilha" de front-end, passando pelo armazenamento e processamento de dados de vários padrões concorrentes, até a garantia dos mais altos níveis de segurança e desempenho, os desenvolvedores são obrigados a garantir que o aplicativo seja dimensionado, tenha um bom desempenho e seja compatível com várias plataformas. Para esse último requisito, agrupar o aplicativo em tecnologias de contêiner, como o Docker, e implantar vários contêineres na plataforma Kubernetes agora é importante no desenvolvimento de aplicativos.

Neste exemplo, exploramos o uso de Python, contêineres do Docker e Kubernetes — todos em execução na plataforma Microsoft Azure. Usando o Kubernetes você tem a flexibilidade de usar ambientes locais ou até mesmo outras nuvens para uma implantação perfeita e consistente do aplicativo além de ter a possibilidade de implantações multinuvem para uma resiliência ainda maior. Também usaremos o Banco de Dados SQL do Microsoft Azure para um ambiente baseado em serviços, escalonável, altamente resiliente e seguro para o armazenamento e processamento de dados. Na verdade, em muitos casos, outros aplicativos já estão usando o Banco de Dados SQL do Microsoft Azure, e esse aplicativo de exemplo pode ser usado para usar e enriquecer ainda mais esses dados.

Este exemplo é bastante abrangente no escopo, mas usa o aplicativo, o banco de dados e a implantação mais simples para ilustrar o processo. Você pode adaptar essa amostra para ser muito mais robusto, inclusive usando as tecnologias mais recentes para os dados devolvidos. É uma ferramenta de aprendizagem útil para criar um padrão para outros aplicativos.

Use Python, contêineres do Docker, Kubernetes e o banco de dados de amostra AdventureWorksLT em um exemplo prático

A empresa AdventureWorks (fictícia) usa um banco de dados que armazena dados sobre vendas e marketing, produtos, clientes e fabricação. Ele também contém exibições e procedimentos armazenados que unem informações sobre os produtos, como o nome do produto, categoria, preço e uma breve descrição.

A equipe de desenvolvimento do AdventureWorks deseja criar uma prova de conceito (PoC) que devolva dados de uma exibição no AdventureWorksLT banco de dados e disponibilizá-los como uma API REST. Usando essa PoC, a equipe de desenvolvimento criará um aplicativo mais escalonável e pronto para multinuvem para a equipe de vendas. A equipe escolheu a plataforma Microsoft Azure para todos os aspectos da implantação. O PoC está usando os seguintes elementos:

  • Um aplicativo Python usando o pacote Flask para implantação da Web sem periféricos.
  • Contêineres do Docker para isolamento de código e ambiente, armazenados em um registro privado para que toda a empresa possa reutilizar os contêineres de aplicativos em projetos futuros, poupando tempo e dinheiro.
  • Kubernetes para facilitar a implantação e escala bem como para evitar o bloqueio da plataforma.
  • Banco de Dados SQL do Microsoft Azure para seleção de dimensão, desempenho, escala, gerenciamento automático e backup, além de armazenamento e processamento de dados relacionais no mais alto nível de segurança.

Neste artigo, explicamos o processo de criação de todo o projeto de prova de conceito. As etapas gerais para criar o aplicativo são:

  1. Definir pré-requisitos
  2. Criar o aplicativo
  3. Criar um contêiner do Docker para implantar o aplicativo e testar
  4. Criar um registro do Serviço de Contêiner do Azure (ACS) e carregar o contêiner no Registro ACS
  5. Criar o ambiente do Serviço de Kubernetes do Azure (AKS)
  6. Implantar o contêiner de aplicativo do Registro ACS no AKS
  7. Testar o aplicativo
  8. Limpeza

Pré-requisitos

Ao longo deste artigo, há vários valores que você deve substituir. Certifique-se de substituir com consistência esses valores para cada etapa. Talvez seja interessante você abrir um editor de texto e colar esses valores para usar os valores corretos ao longo do projeto de prova de conceito:

  • ReplaceWith_AzureSubscriptionName: mude esse valor pelo nome da assinatura do Azure que você tem.
  • ReplaceWith_PoCResourceGroupName: mude esse valor pelo nome do grupo de recursos que você gostaria de criar.
  • ReplaceWith_AzureSQLDBServerName: mude esse valor pelo nome do servidor lógico do Banco de Dados SQL do Azure que você cria usando o portal do Azure.
  • ReplaceWith_AzureSQLDBSQLServerLoginName: mude esse valor pelo valor do nome de usuário do SQL Server criado no portal do Azure.
  • ReplaceWith_AzureSQLDBSQLServerLoginPassword: mude esse valor pelo valor da senha de usuário do SQL Server criada no portal do Azure.
  • ReplaceWith_AzureSQLDBDatabaseName: mude esse valor pelo nome do Banco de Dados SQL do Azure que você cria usando o portal do Azure.
  • ReplaceWith_AzureContainerRegistryName: mude esse valor pelo nome do Registro de Contêiner do Azure que você deseja criar.
  • ReplaceWith_AzureKubernetesServiceName: mude esse valor pelo nome do Serviço de Kubernetes do Azure que você gostaria de criar.

Os desenvolvedores da AdventureWorks usam um mix de sistemas Windows, Linux e Apple para desenvolvimento, então eles estão usando o Visual Studio Code como ambiente e o git para o controle do código-fonte, ambos executados entre multiplataformas.

Para a PoC, a equipe exige os seguintes pré-requisitos:

  1. Python, pip e pacotes – A equipe de desenvolvimento escolhe a linguagem de programação Python como o padrão para este aplicativo baseado na Web. Atualmente eles estão usando a versão 3.9, mas qualquer versão que suporte os pacotes necessários PoC é aceitável.

  2. A equipe está usando o pacote pyodbc para acesso ao banco de dados.

  3. A equipe está usando o ConfigParser pacote para controlar e ajustar variáveis de configuração.

  4. A equipe está usando o pacote Flask para uma interface web para o aplicativo.

  5. Em seguida, a equipe instalou a ferramenta CLI do Azure, identificada com facilidade com a sintaxe az. Essa ferramenta de multiplataforma permite uma abordagem de linha de comando e script para a PoC, para que a equipe possa repetir as etapas à medida que faz alterações e melhorias.

  6. Com a CLI do Azure configurada, a equipe inicia a sessão na assinatura do Azure e ajusta o nome da assinatura usada para a PoC. Em seguida, a equipe garantiu que o servidor do banco de dados SQL e o banco de dados do Azure estivessem acessíveis à assinatura:

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

  7. Um grupo de recursos do Microsoft Azure consiste em um contêiner lógico que retém os recursos relacionados para uma solução do Azure. Em geral, recursos que compartilham o mesmo ciclo de vida são adicionados ao mesmo grupo de recursos, para que você possa implantar, atualizar e excluir todos como um grupo facilmente. O grupo de recursos armazena metadados sobre os recursos e é possível especificar uma localização para ele.

    Grupos de recursos podem ser criados e gerenciados usando o portal do Azure ou a CLI do Azure. Eles também podem ser usados para agrupar recursos relacionados para um aplicativo e dividi-los em grupos para produção e não produção, ou qualquer outra estrutura organizacional de sua preferência.

    Captura de tela do portal do Azure mostrando como pesquisar e filtrar os grupos de recursos do Azure.

    No snippet de código a seguir, você pode ver o az comando usado para criar um grupo de recursos. Em nossa amostra, usamos a região eastus do Azure.

    az group create --name ReplaceWith_PoCResourceGroupName --location eastus

  8. A equipe de desenvolvimento cria um Banco de Dados SQL do Azure com o AdventureWorksLT banco de dados de amostra instalado, usando um logon autenticado pelo SQL.

    O AdventureWorks padronizou a plataforma Microsoft SQL Server RDBMS, e a equipe de desenvolvimento deseja usar um serviço gerenciado para o banco de dados em vez de instalar localmente. O uso do Banco de Dados SQL do Azure permite que esse serviço gerenciado seja completamente compatível com o código onde quer que eles executem o mecanismo do SQL Server: localmente, em um contêiner, no Linux ou no Windows ou até mesmo em um ambiente da Internet das Coisas (IoT).

    1. Durante a criação, a equipe usou o Portal de Gerenciamento do Azure para ajustar o Firewall do aplicativo para a máquina de desenvolvimento local e alterou o padrão que você vê aqui para habilitar Permitir todos os Serviços do Azure, e também recuperou as credenciais de conexão.

      Captura de tela do portal do Azure mostrando a página Criar banco de dados SQL. Na guia Sistema de rede, para Método de conectividade, a opção Ponto de extremidade público está selecionada. A opção Adicionar endereço IP do cliente atual é Sim.

      Com essa abordagem, o banco de dados poderia ser acessado em outra região ou até mesmo em uma assinatura diferente.

    2. A equipe configurou um logon autenticado SQL para teste, mas revisitará essa decisão em uma revisão de segurança.

    3. A equipe usou o banco de dados de amostra AdventureWorksLT para a PoC usando o mesmo grupo de recursos da PoC. Não se preocupe, no final deste tutorial, limparemos todos os recursos neste novo grupo de recursos PoC.

    4. Você pode usar o portal do Azure para implantar o Banco de Dados SQL do Azure. Ao criar o Banco de Dados SQL do Azure, na Tab Configurações adicionais, para a opção Usar dados existentes, selecione Amostra.

      Captura de tela do portal do Azure mostrando a página Criar banco de dados SQL. Na guia Configurações adicionais, para a opção Usar dados existentes, selecione Amostra.

    5. Por fim, na Tab Tags do novo Banco de Dados SQL do Azure, a equipe de desenvolvimento forneceu metadados de tags para esse recurso do Azure, como Proprietário ou ServiceClass ou WorkloadName.

Criar o aplicativo

Em seguida, a equipe de desenvolvimento criou um aplicativo Python simples que abre uma conexão com o Banco de Dados SQL do Azure e devolve uma lista de produtos. Esse código será substituído por funções mais complexas e também poderá incluir mais de um aplicativo implantado nos Kubernetes Pods em produção para uma abordagem robusta e orientada a manifestos para soluções de aplicativos.

  1. A equipe criou um arquivo de texto simples chamado .env para armazenar variáveis para as conexões do servidor e outras informações. Com o uso da biblioteca python-dotenv, a equipe pode separar as variáveis do Código Python. Essa é uma abordagem comum para manter segredos e outras informações fora do próprio código.

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

    Cuidado

    Para clareza e simplicidade, este aplicativo está usando um arquivo de configuração que é lido a partir do Python. Como o código será implantado com o contêiner, as informações de conexão podem ser derivadas do conteúdo. Você deve considerar cuidadosamente os vários métodos de trabalhar com segurança, conexões e segredos e determinar o melhor nível e mecanismo que você deve usar para nossa aplicação. Escolha sempre o mais alto nível de segurança e até mesmo vários níveis para garantir que seu aplicativo esteja seguro. Você tem várias opções de trabalhar com informações secretas, como cadeias de conexão e afins. A lista a seguir mostra algumas dessas opções.

    Para mais informações, veja Segurança do Banco de Dados SQL do Azure.

  2. Em seguida, a equipe escreveu o aplicativo PoC e o chamouapp.py.

    O script a seguir realiza estas etapas:

    1. Configure as bibliotecas para a configuração e as interfaces web de base.
    2. Carregue as variáveis do arquivo .env.
    3. Crie o aplicativo Flask-RESTful.
    4. Obtenha informações de conexão de Banco de Dados SQL do Azure usando os valores do arquivoconfig.ini.
    5. Crie conexão com o Banco de Dados SQL do Azure usando os valores do arquivo config.ini.
    6. Conectar-se ao Banco de dados SQL do Azure usando o pacotepyodbc.
    7. Crie a consulta SQL a ser executada no banco de dados.
    8. Crie a classe que será usada para devolver os dados da API.
    9. Configure o ponto de extremidade de API para a classe Products.
    10. Finalmente, inicie o aplicativo na porta padrão 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. Houve uma verificação para confirmar se esse aplicativo é executado localmente e devolve uma página para http://localhost:5000/products.

    Captura de tela de um navegador da Web da página de retorno do Flask.

    Importante

    Ao criar aplicativos de produção, não use a conta de administrador para acessar o banco de dados. Para obter mais informações, leia mais sobre as instruções para configurar uma conta para seu aplicativo. O código neste artigo é simplificado para que você possa iniciar rapidamente aplicativos usando Python e Kubernetes no Azure.

    De forma mais realista, você poderia usar um usuário de banco de dados independente com permissões somente leitura ou um usuário de logon ou banco de dados independente conectado a uma identidade gerenciada atribuída pelo usuário com permissões somente leitura.

    Para obter mais informações, consulte um exemplo completo com instruções para criar API com Python e Banco de Dados SQL do Azure.

Implantar o aplicativo a um contêiner do Docker

Um contêiner é um espaço reservado e protegido em um sistema de computação que fornece isolamento e encapsulamento. Para criar um contêiner, use um arquivo de manifesto, que é simplesmente um arquivo de texto que descreve os binários e o código que você deseja conter. Com o uso de um contêiner Runtime (como o Docker), você pode criar uma imagem binária que tenha todos os arquivos que deseja executar e referenciar. A partir daí, você pode "executar" a imagem binária, e isso é chamado de Contêiner, que você pode referenciar como se fosse um sistema de computação completo. É uma maneira menor e mais simples de abstrair os application runtimes e seu ambiente do que usar uma máquina virtual completa. Para obter mais informações, veja Contêineres e Docker.

A equipe começou com um DockerFile (o Manifesto) que agrupa os elementos dentre os quais a equipe deseja usar. A equipe começa com uma imagem Python base que já tem as pyodbc bibliotecas instaladas e, em seguida, executa todos os comandos necessários para conter o programa e o arquivo de configuração na etapa anterior.

O seguinte Dockerfile tem as seguintes etapas:

  1. Comece com um binário de contêiner que já tenha Python e pyodbc instalado.
  2. Criar o diretório de trabalho para o aplicativo.
  3. Copie todo o código do diretório atual para o WORKDIR.
  4. Instale as bibliotecas necessárias.
  5. Quando o contêiner for iniciado, execute o aplicativo e abra todas as portas 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"]

Com esse arquivo no lugar, a equipe caiu em um prompt de comando no diretório de codificação e executou o seguinte código para criar a imagem binária do manifesto e, em seguida, outro comando para iniciar o contêiner:

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

Mais uma vez, a equipe testa o link http://localhost:5000/products para garantir que o contêiner possa acessar o banco de dados e verá o seguinte retorno:

Captura de tela de um navegador da Web da página de retorno do Flask a partir do contêiner.

Implantar a imagem em um registro do Docker

O contêiner agora está funcionando, mas só está disponível na máquina do desenvolvedor. A equipe de desenvolvimento gostaria de disponibilizar essa imagem do aplicativo para o resto da empresa e, em seguida, para o Kubernetes para implantação em produção.

A área de armazenamento para imagens de contêiner é chamada de repositório e pode haver repositórios públicos e privados para imagens de contêiner. Na verdade, a AdvenureWorks usou uma imagem pública para o ambiente Python em seu Dockerfile.

A equipe gostaria de controlar o acesso à imagem e, em vez de colocá-la na Web, decide que gostaria de hospedá-la por conta própria, mas no Microsoft Azure, onde tem controle total sobre a segurança e o acesso. Você pode ler mais sobre o Registro de Contêiner do Microsoft Azure aqui.

Voltando à linha de comando, a equipe de desenvolvimento usa az CLI para adicionar um serviço de registro de contêiner, habilitar uma conta de administrador, defini-la como "pulls" anônimos durante a fase de teste e ajustar um contexto de logon para o 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

Esse contexto será utilizado nas etapas subsequentes.

Marcar a imagem local do Docker para prepará-la para fazer upload

A próxima etapa é enviar a Imagem de Contêiner do aplicativo local para o serviço ACR (Registro de Contêiner do Azure) para que ele esteja disponível na nuvem.

  1. No script de exemplo a seguir, a equipe usa os comandos do Docker para listar as imagens na máquina.
  2. A equipe usa o utilitário az CLI para listar as imagens no serviço ACR.
  3. O comando Docker é usado para "marcar" a imagem com o nome de destino do ACR criado na etapa anterior e para definir um número de versão para o DevOps adequado.
  4. Finalmente, a equipe lista as informações da imagem local novamente para garantir que a tag seja aplicada corretamente.
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

Com o código escrito e testado, o Dockerfile, a imagem e o contêiner executados e testados, o serviço ACR configurado e todas as tags aplicadas, a equipe pode carregar a imagem no serviço ACR.

O comando "push" do Docker é usado para enviar o arquivo e, em seguida, o utilitário az CLI para garantir que a imagem foi carregada:

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

Implantar para o Kubernetes

A equipe poderia simplesmente executar contêineres e implantar o aplicativo em ambientes locais e na nuvem. No entanto, eles gostariam de adicionar várias cópias do aplicativo para dimensionamento e disponibilidade, adicionar outros contêineres executando tarefas diferentes e adicionar monitoramento e instrumentação a toda a solução.

Para agrupar contêineres em uma solução completa, a equipe decidiu usar o Kubernetes. O Kubernetes é executado no local e em todas as principais plataformas de nuvem. O Microsoft Azure tem um ambiente gerenciado completo para o Kubernetes, chamado de AKS (Serviço de Kubernetes do Azure). Saiba mais sobre o AKS com o caminho de treinamento Introdução ao Kubernetes no Azure.

Ao usar o utilitário az CLI, a equipe adiciona AKS ao mesmo grupo de recursos que criou anteriormente. Com um único comando az, a equipe de desenvolvimento realiza as seguintes etapas:

  • Adicione dois "nós" ou ambientes de computação para resiliência na fase de teste
  • Gerar automaticamente chaves SSH para acesso ao ambiente
  • Anexe o serviço ACR criado nas etapas anteriores para que o cluster AKS possa localizar as imagens que deseja usar para a implantação
az aks create --resource-group ReplaceWith_PoCResourceGroupName --name ReplaceWith_AzureKubernetesServiceName --node-count 2 --generate-ssh-keys --attach-acr ReplaceWith_AzureContainerRegistryName

O Kubernetes usa uma ferramenta de linha de comando para acessar e controlar um cluster, chamada kubectl. A equipe usa o utilitário az CLI para download da ferramenta kubectl e instalá-la:

az aks install-cli

Como a equipe tem uma conexão com o AKS no momento, ela pode pedir que ele envie as chaves SSH para conexão a serem usadas quando executar o utilitário kubectl:

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

Essas chaves são armazenadas em um arquivo chamado .config no diretório do usuário. Com esse contexto de segurança definido, a equipe usa kubectl get nodes para mostrar os nós no cluster:

kubectl get nodes

Agora, a equipe usa a ferramenta az CLI para listar as imagens no serviço ACR:

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

Agora ela pode criar o manifesto que o Kubernetes usa para controlar a implantação. Este é um arquivo de texto armazenado em um formato yaml. Aqui está o texto anotado no arquivo 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

Com o arquivo definido flask2sql.yaml, a equipe pode implantar o aplicativo no cluster AKS em execução. Isso é feito com o comando kubectl apply, que, como você lembra, ainda tem um contexto de segurança para o cluster. Em seguida, o comando kubectl get service é enviado para observar o cluster enquanto ele está sendo criado.

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

Após alguns instantes, o comando "watch" devolverá um endereço IP externo. Nesse ponto, a equipe pressiona CTRL-C para quebrar o comando de inspeção e registra o endereço IP externo do balanceador de carga.

Testar o aplicativo

Com o uso do endereço IP (ponto de extremidade) obtido na última etapa, a equipe verifica para garantir a mesma saída que o aplicativo local e o contêiner do Docker:

Captura de tela de um navegador da Web da página de retorno do Flask quando finalmente testamos o contêiner. A saída é a mesma de antes.

Limpar

Com o aplicativo criado, editado, documentado e testado, a equipe agora pode "derrubar" o aplicativo. Ao manter tudo em um único grupo de recursos no Microsoft Azure, é uma questão simples excluir o grupo de recursos PoC usando o utilitário az CLI:

az group delete -n ReplaceWith_PoCResourceGroupName -y

Observação

Se você criou o Banco de Dados SQL do Azure em outro grupo de recursos e não precisa mais dele, pode usar o portal do Azure para excluí-lo.

O membro da equipe que lidera o projeto PoC usa o Microsoft Windows como sua estação de trabalho e deseja reter o arquivo de segredos do Kubernetes, mas removê-lo do sistema como a localização ativa. A equipe pode simplesmente copiar o arquivo para um arquivo de texto config.old e, em seguida, excluí-lo:

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

Conteúdo relacionado