Início Rápido: Implantações repetíveis com o driver mssql-python para Python

Neste início rápido, você usará uv para gerenciar dependências de projeto e ambientes para um script Python que se conecta a um banco de dados que você criou e carregou com dados de exemplo. Você usa o mssql-python driver do Python para se conectar ao seu banco de dados e realizar operações básicas, como ler e escrever dados.

O mssql-python driver não requer nenhuma dependência externa em computadores Windows. O driver instala tudo o que precisa com uma única pip instalação, permitindo que você use a versão mais recente do driver para novos scripts sem quebrar outros scripts que você não tem tempo para atualizar e testar.

Documentação do mssql-pythonCódigo-fonte mssql-pythonPacote (PyPI)uv

Pré-requisitos

Pré-requisitos para instalar o sistema operacional

Instale pré-requisitos específicos do sistema operacional uma vez. Usuários do Windows podem pular essa etapa. Para detalhes completos da plataforma, veja Instalar mssql-python.

apk add libtool krb5-libs krb5-dev libstdc++

Criar um banco de dados SQL

Crie ou conecte-se a um banco de dados SQL em uma das seguintes plataformas:

Criar o projeto e executar o código

Criar um novo projeto

  1. Abra um prompt de comando no diretório de desenvolvimento. Se você não tiver um, crie um novo diretório, como python ou scripts. Evite pastas no seu OneDrive, pois a sincronização pode interferir no gerenciamento do seu ambiente virtual.

  2. Crie um novo projeto com uv.

    uv init mssql-python-repeatable-qs
cd mssql-python-repeatable-qs

Adicionar dependências

No mesmo diretório, instale os pacotes mssql-python, python-dotenv e rich.

uv add mssql-python python-dotenv rich

Iniciar o Visual Studio Code

No mesmo diretório, execute o comando a seguir.

code .

Atualizar pyproject.toml

  1. Abra o arquivo pyproject.toml no editor. Este arquivo contém os metadados do seu projeto.

  2. Examine o conteúdo do arquivo. Deve ser semelhante a este exemplo. Observe a versão do Python e a dependência para mssql-python; use >= para definir uma versão mínima. Se preferir uma versão exata, altere o >= para == antes do número da versão. As versões resolvidas de cada pacote são armazenadas no uv.lock. O lockfile garante que os desenvolvedores que trabalham no projeto utilizem versões consistentes de pacotes. Ele também garante que exatamente o mesmo conjunto de versões de pacote seja usado ao distribuir seu pacote para os usuários finais. Faça commit tanto em pyproject.toml quanto em uv.lock, revise as alterações de lockfile em solicitações de pull e execute um scanner de dependências aprovado pela organização no CI. Não edite o uv.lock arquivo diretamente.

    [project]
name = "mssql-python-repeatable-qs"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.11"
dependencies = [
    "mssql-python>=1.16.0",
    "python-dotenv>=1.1.1",
    "rich>=14.1.0",
]

  3. Atualizar o valor description.

    description = "Connects to a SQL database using mssql-python"

  4. Salve e feche o arquivo.

Atualizar main.py

  1. Abra o arquivo chamado main.py. Deve ser semelhante a este exemplo.

    def main():
    print("Hello from mssql-python-repeatable-qs!")

if __name__ == "__main__":
    main()

  2. No topo do arquivo, adicione as seguintes importações antes da linha com def main().

    Dica

    Se o Visual Studio Code estiver tendo problemas para resolver pacotes, você precisará atualizar o interpretador para usar o ambiente virtual.

    from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection, Cursor
from rich.console import Console
from rich.progress import Progress, SpinnerColumn, TextColumn
from rich.table import Table
from argparse import ArgumentParser
from time import sleep

  3. Entre as importações e a linha com def main(), adicione o código a seguir.

    def get_results(sleep_time: int = 0) -> None:
    with Progress(
        SpinnerColumn(),
        TextColumn("[progress.description]{task.description}"),
        transient=True,
    ) as progress:
        task = progress.add_task(description="Connecting to SQL...")

        cursor = query_sql()

        # Simulate a slow connection for demo purposes
        sleep(sleep_time)

        progress.update(task, description="Formatting results...")

        table = Table(title="Orders by Customer")
        # https://rich.readthedocs.io/en/stable/appendix/colors.html
        table.add_column("Customer ID", style="bright_blue", justify="center")
        table.add_column("Company Name", style="bright_white", justify="left")
        table.add_column("Order Count", style="bold green", justify="right")

        records = cursor.fetchall()
        for r in records:
            table.add_row(f"{r.CustomerID}", f"{r.CompanyName}", f"{r.OrderCount}")

        if cursor:
            cursor.close()

        # Simulate a slow connection for demo purposes
        sleep(sleep_time)

        progress.stop()

        Console().print(table)

  4. Entre as importações e def get_results(sleep_time: int = 0) -> None:, adicione este código.

    _connection = None

def get_connection() -> Connection:
    global _connection
    if not _connection:
        load_dotenv()
        _connection = connect(getenv("SQL_CONNECTION_STRING"))  # type: ignore
    return _connection

def query_sql() -> Cursor:
    SQL_QUERY = """
    SELECT TOP 5
        c.CustomerID,
        c.CompanyName,
        COUNT(soh.SalesOrderID) AS OrderCount
    FROM SalesLT.Customer AS c
    LEFT OUTER JOIN SalesLT.SalesOrderHeader AS soh
        ON c.CustomerID = soh.CustomerID
    GROUP BY
        c.CustomerID,
        c.CompanyName
    ORDER BY OrderCount DESC;
    """

    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute(SQL_QUERY)
    return cursor

  5. Localize este código.

    def main():
    print("Hello from mssql-python-repeatable-qs!")

  6. Substitua-o por esse código.

    def main() -> None:
    parser = ArgumentParser()
    parser.add_argument("--sleep-time", type=int, default=0,
                        help="Time to sleep in seconds to simulate slow connection")
    args = parser.parse_args()

    if args.sleep_time > 0:
        get_results(args.sleep_time)
    else:
        get_results()

    if _connection:
        _connection.close()

  7. Salvar e fechar main.py.

Salvar a cadeia de conexão

  1. Abra o .gitignore arquivo e adicione uma exclusão para .env arquivos. Seu arquivo deve ser semelhante ao exemplo a seguir.

    # Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv

# Connection strings and secrets
.env

  2. Salvar e fechar .gitignore.

  3. No diretório atual, crie um novo arquivo chamado .env.

  4. No arquivo .env, adicione uma entrada para sua string de conexão chamada SQL_CONNECTION_STRING. Substitua os marcadores de posição pelos seus valores reais.

    SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"

    Importante

    Mantenha .env local e fora do controle de código-fonte. Para ambientes de CI e implantação, injete a cadeia de caracteres de conexão ou os segredos de seus componentes do armazenamento de segredos da sua plataforma, em vez de copiar .env de uma máquina para outra.

    A cadeia de conexão depende do tipo de banco de dados SQL ao qual você está se conectando. Para Banco de Dados SQL do Azure ou SQL Database no Fabric, use a cadeia de conexão ODBC da aba de strings de conexão e ajuste o tipo de autenticação para o seu cenário. Para mais informações sobre a sintaxe das cadeia de conexão, veja Connection strings for mssql-python.

    Dica

    No macOS, tanto ActiveDirectoryInteractive quanto ActiveDirectoryDefault funcionam para autenticação do Microsoft Entra. ActiveDirectoryInteractive solicita que você faça login toda vez que executar o script. Para evitar prompts repetidos de login, faça login uma vez com o comando CLI do Azureaz login e use ActiveDirectoryDefault. ActiveDirectoryDefault reutiliza a credencial em cache.

Use o comando uv run para executar o script

  1. Na janela do terminal de antes ou em uma nova janela de terminal aberta para o mesmo diretório, execute o comando a seguir.

    uv run main.py

  2. Execute o script novamente com um atraso para que você possa ver as duas atualizações de status.

    uv run main.py --sleep-time 5

    Esta é a saída esperada quando o script é concluído.

                             Orders by Customer
┏━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┓
┃ Customer ID ┃ Company Name                   ┃ Order Count ┃
┡━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━┩
│    29485    │ Professional Sales and Service │           1 │
│    29531    │ Remarkable Bike Store          │           1 │
│    29546    │ Bulk Discount Store            │           1 │
│    29568    │ Coalition Bike Company         │           1 │
│    29584    │ Futuristic Bikes               │           1 │
└─────────────┴────────────────────────────────┴─────────────┘

  3. Para implantar seu script em outra máquina, copie os arquivos do projeto, incluindo pyproject.toml e , mas não a uv.lock pasta nem qualquer arquivo local .venv.env. Recrie o ambiente virtual na primeira execução e forneça os segredos por meio do ambiente de destino.

Conteúdo relacionado

  • Última atualização em