Exemplo: criar Armazenamento do Azure com as bibliotecas do Azure para Python

Artigo
07/29/2024

Neste artigo, você aprenderá a usar as bibliotecas de gerenciamento do Azure em um script do Python para criar um grupo de recursos que contém uma conta do Armazenamento do Microsoft Azure e um contêiner de armazenamento de Blobs.

Após criar os recursos, consulte Exemplo: usar Armazenamento do Azure para usar as bibliotecas de cliente do Azure no código do aplicativo Python para carregar um arquivo no contêiner de armazenamento de Blobs.

Todos os comandos neste artigo funcionam da mesma forma no bash do Linux/macOS e nos shells de comando do Windows, a menos que haja uma observação.

Os Comandos equivalentes da CLI do Azure serão listados depois neste artigo. Se preferir usar o portal do Azure, confira Criar uma conta de Armazenamento do Microsoft Azure e Criar um contêiner de blobs.

1: configurar seu ambiente de desenvolvimento

Caso ainda não tenha feito isso, configure um ambiente onde você possa executar o código. Estas são algumas opções:

Configure um ambiente virtual Python usando o venv ou sua ferramenta de escolha. Você pode criar o ambiente virtual localmente ou no Azure Cloud Shell e executar o código lá. Não esqueça de ativar o ambiente virtual para começar a usá-lo.
Use um ambiente conda.
Use um Contêiner de Desenvolvimento no Visual Studio Code ou no GitHub Codespaces.

2: instalar os pacotes de biblioteca do Azure necessários

Crie um arquivo requirements.txt que liste as bibliotecas de gerenciamento usadas neste exemplo:
```
azure-mgmt-resource
azure-mgmt-storage
azure-identity
```
Em seu terminal com o ambiente virtual ativado, instale os requisitos:
```
pip install -r requirements.txt
```

3: escrever um código para criar recursos de armazenamento

Crie um arquivo Python com o nome provision_blob.py com o código a seguir. Os comentários explicam os detalhes. O script lê sua ID de assinatura de uma variável de ambiente, AZURE_SUBSCRIPTION_ID. Você definirá essa variável em uma etapa posterior. O nome do grupo de recursos, o local, o nome da conta de armazenamento e o nome do contêiner são definidos como constantes no código.

import os, random

# Import the needed management objects from the libraries. The azure.common library
# is installed automatically with the other libraries.
from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.storage import StorageManagementClient

# Acquire a credential object.
credential = DefaultAzureCredential()

# Retrieve subscription ID from environment variable.
subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]

# Obtain the management object for resources.
resource_client = ResourceManagementClient(credential, subscription_id)

# Constants we need in multiple places: the resource group name and the region
# in which we provision resources. You can change these values however you want.
RESOURCE_GROUP_NAME = "PythonAzureExample-Storage-rg"
LOCATION = "centralus"

# Step 1: Provision the resource group.

rg_result = resource_client.resource_groups.create_or_update(RESOURCE_GROUP_NAME,
    { "location": LOCATION })

print(f"Provisioned resource group {rg_result.name}")

# For details on the previous code, see Example: Provision a resource group
# at https://docs.microsoft.com/azure/developer/python/azure-sdk-example-resource-group


# Step 2: Provision the storage account, starting with a management object.

storage_client = StorageManagementClient(credential, subscription_id)

STORAGE_ACCOUNT_NAME = f"pythonazurestorage{random.randint(1,100000):05}"

# You can replace the storage account here with any unique name. A random number is used
# by default, but note that the name changes every time you run this script.
# The name must be 3-24 lower case letters and numbers only.


# Check if the account name is available. Storage account names must be unique across
# Azure because they're used in URLs.
availability_result = storage_client.storage_accounts.check_name_availability(
    { "name": STORAGE_ACCOUNT_NAME }
)

if not availability_result.name_available:
    print(f"Storage name {STORAGE_ACCOUNT_NAME} is already in use. Try another name.")
    exit()

# The name is available, so provision the account
poller = storage_client.storage_accounts.begin_create(RESOURCE_GROUP_NAME, STORAGE_ACCOUNT_NAME,
    {
        "location" : LOCATION,
        "kind": "StorageV2",
        "sku": {"name": "Standard_LRS"}
    }
)

# Long-running operations return a poller object; calling poller.result()
# waits for completion.
account_result = poller.result()
print(f"Provisioned storage account {account_result.name}")


# Step 3: Retrieve the account's primary access key and generate a connection string.
keys = storage_client.storage_accounts.list_keys(RESOURCE_GROUP_NAME, STORAGE_ACCOUNT_NAME)

print(f"Primary key for storage account: {keys.keys[0].value}")

conn_string = f"DefaultEndpointsProtocol=https;EndpointSuffix=core.windows.net;AccountName={STORAGE_ACCOUNT_NAME};AccountKey={keys.keys[0].value}"

print(f"Connection string: {conn_string}")

# Step 4: Provision the blob container in the account (this call is synchronous)
CONTAINER_NAME = "blob-container-01"
container = storage_client.blob_containers.create(RESOURCE_GROUP_NAME, STORAGE_ACCOUNT_NAME, CONTAINER_NAME, {})

# The fourth argument is a required BlobContainer object, but because we don't need any
# special values there, so we just pass empty JSON.

print(f"Provisioned blob container {container.name}")

Autenticação no código

Mais adiante neste artigo, você entra no Azure com a CLI do Azure para executar o código de exemplo. Se sua conta tiver permissões para criar grupos de recursos e recursos de armazenamento em sua assinatura do Azure, o código será executado com êxito.

Para usar esse código em um script de produção, você pode definir variáveis de ambiente para usar um método baseado em entidade de serviço para autenticação. Para saber mais, confira Como autenticar aplicativos Python com serviços do Azure. Você precisa garantir que a entidade de serviço tenha permissões suficientes para criar grupos de recursos e recursos de armazenamento em sua assinatura, atribuindo uma função apropriada no Azure; por exemplo, a função Colaborador na sua assinatura.

Links de referência para classes usadas no código

4. Executar o script

Caso ainda não tenha feito isso, entre no Azure usando a CLI do Azure:
```
az login
```
Defina a variável de ambiente AZURE_SUBSCRIPTION_ID como a sua ID da assinatura. (Você pode executar o comando az account show e obter sua ID de assinatura da propriedade id na saída):
- cmd
- Bash
```
set AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
```
```
AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
```
Executar o script:
```
python provision_blob.py
```

O script levará alguns minutos para ser concluído.

5: verificar os recursos

Abra o portal do Azure para verificar se o grupo de recursos e a conta de armazenamento foram criados como esperado. Talvez seja necessário aguardar um minuto e também selecionar Mostrar tipos ocultos no grupo de recursos.
Escolha a conta de armazenamento e selecione Armazenamento de dados>Contêineres no menu à esquerda para verificar se o "blob-container-01" é exibido:
Se você quiser tentar usar esses recursos criados do código do aplicativo, continue com Exemplo: usar Armazenamento do Azure.

Para obter mais um exemplo que usa a biblioteca de gerenciamento do Armazenamento do Microsoft Azure, consulte Gerenciar amostra de Armazenamento do Python.

Para referência: comandos equivalentes da CLI do Azure

Os seguintes comandos da CLI do Azure CLI completam as mesmos etapas de criação que o script Python:

cmd
Bash

rem Provision the resource group

az group create ^
-n PythonAzureExample-Storage-rg ^
-l centralus

rem Provision the storage account

set account=pythonazurestorage%random%
echo Storage account name is %account%

az storage account create ^
-g PythonAzureExample-Storage-rg ^
-l centralus ^
-n %account% ^
--kind StorageV2 ^
--sku Standard_LRS

rem Retrieve the connection string

FOR /F %i IN ('az storage account show-connection-string -g PythonAzureExample-Storage-rg -n %account% --query connectionString') do (SET connstr=%i)

rem Provision the blob container

az storage container create ^
--name blob-container-01 ^
--account-name %account% ^
--connection-string %connstr%

# Provision the resource group

az group create \
-n PythonAzureExample-Storage-rg \
-l centralus

# Provision the storage account

ACCOUNT_NAME=pythonazurestorage$(echo $RANDOM | md5sum | head -c 6)

az storage account create \
-g PythonAzureExample-Storage-rg \
-l centralus \
-n $ACCOUNT_NAME \
--kind StorageV2 \
--sku Standard_LRS

# Retrieve the connection string

echo Storage account name is $ACCOUNT_NAME

CONNECTION_STRING=$(az storage account show-connection-string \
-g PythonAzureExample-Storage-rg \
-n $ACCOUNT_NAME \
--query connectionString)

# Provision the blob container

az storage container create --name "blob-container-01" \
--account-name $ACCOUNT_NAME \
--connection-string $CONNECTION_STRING

6: limpar recursos

Deixe os recursos em vigor se quiser seguir o artigo Exemplo: usar o Armazenamento do Azure para usar esses recursos no código do aplicativo. Caso contrário, execute o comando az group delete se você não precisar manter o grupo de recursos e os recursos de armazenamento criados neste exemplo.

Os grupos de recursos não incorrem em encargos adicionais em sua assinatura, mas recursos, como contas de armazenamento, no grupo de recursos podem incorrer em encargos. É prática recomendada limpar qualquer grupo que você não esteja usando ativamente. O argumento --no-wait permite que o comando seja retornado imediatamente, em vez de esperar a conclusão da operação.

az group delete -n PythonAzureExample-Storage-rg  --no-wait

Você também pode usar o método ResourceManagementClient.resource_groups.begin_delete para excluir um grupo de recursos do código. O código em Exemplo: criar um grupo de recursos demonstra o uso.

Compartilhar via