Condividi tramite

Esempio: Creare Archiviazione di Azure usando le librerie di Azure per Python

Questo articolo illustra come usare le librerie di gestione di Azure per Python per creare un gruppo di risorse, insieme a un account di archiviazione di Azure e a un contenitore di archiviazione BLOB.

Dopo il provisioning di queste risorse, vedere la sezione Esempio: Usare Archiviazione di Azure per vedere come usare le librerie client di Azure in Python per caricare un file nel contenitore Blob.

I comandi equivalenti dell'interfaccia della riga di comando di Azure per bash e PowerShell sono elencati più avanti in questo articolo. Se si preferisce usare il portale di Azure, vedere Creare un account di archiviazione di Azure e Creare un contenitore BLOB.

1: Configurare l'ambiente di sviluppo locale

Se non è già stato fatto, configurare un ambiente in cui è possibile eseguire il codice. Ecco alcune opzioni:

  • Configurare un ambiente virtuale Python usando venv o lo strumento preferito. Per iniziare a usare l'ambiente virtuale, assicurarsi di attivarlo. Per installare Python, vedere Installare Python.

    #!/bin/bash
# Create a virtual environment
python -m venv .venv
# Activate the virtual environment
source .venv/Scripts/activate # only required for Windows (Git Bash)

  • Usa un ambiente conda . Per installare Conda, vedere Installare Miniconda.

  • Usare un contenitore di sviluppo in Visual Studio Code o GitHub Codespaces.

2: Installare i pacchetti di libreria di Azure necessari

  1. Nella console creare un filerequirements.txt che elenca le librerie di gestione usate in questo esempio:

    azure-mgmt-resource
azure-mgmt-storage
azure-identity

  2. Nella console con l'ambiente virtuale attivato installare i requisiti:

    pip install -r requirements.txt

3. Impostare le variabili di ambiente

In questo passaggio vengono impostate le variabili di ambiente da usare nel codice in questo articolo. Il codice usa il os.environ metodo per recuperare i valori.

#!/bin/bash
export AZURE_RESOURCE_GROUP_NAME=<ResourceGroupName> # Change to your preferred resource group name
export LOCATION=<Location> # Change to your preferred region
export AZURE_SUBSCRIPTION_ID=$(az account show --query id --output tsv)
export STORAGE_ACCOUNT_NAME=<StorageAccountName> # Change to your preferred storage account name
export CONTAINER_NAME=<ContainerName> # Change to your preferred container name

4: Scrivere codice per creare un account di archiviazione e un contenitore BLOB

In questo passaggio viene creato un file Python denominato provision_blob.py con il codice seguente. Questo script Python usa le librerie di gestione di Azure SDK per Python per creare un gruppo di risorse, un account di archiviazione di Azure e un contenitore BLOB usando Azure SDK per Python.

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
from azure.mgmt.storage.models import BlobContainer

# Acquire a credential object.
credential = DefaultAzureCredential()

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

# Retrieve resource group name and location from environment variables
RESOURCE_GROUP_NAME = os.environ["AZURE_RESOURCE_GROUP_NAME"]
LOCATION = os.environ["LOCATION"]

# Step 1: Provision the resource group.
resource_client = ResourceManagementClient(credential, subscription_id)

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 = os.environ["STORAGE_ACCOUNT_NAME"] 

# 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 = os.environ["CONTAINER_NAME"]
container = storage_client.blob_containers.create(RESOURCE_GROUP_NAME, STORAGE_ACCOUNT_NAME, CONTAINER_NAME, BlobContainer())

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

Autenticazione nel codice

Più avanti in questo articolo si accede ad Azure usando l'interfaccia della riga di comando di Azure per eseguire il codice di esempio. Se l'account dispone di autorizzazioni sufficienti per creare gruppi di risorse e risorse di archiviazione nella sottoscrizione di Azure, lo script deve essere eseguito correttamente senza configurazione aggiuntiva.

Per usare questo codice in un ambiente di produzione, eseguire l'autenticazione usando un'entità servizio impostando le variabili di ambiente. Questo approccio consente l'accesso sicuro e automatizzato senza basarsi sull'accesso interattivo. Per indicazioni dettagliate, vedere Come autenticare le app Python con i servizi di Azure.

Assicuratevi che al principale del servizio sia assegnato un ruolo con autorizzazioni sufficienti per creare gruppi di risorse e account di archiviazione. Ad esempio, l'assegnazione del ruolo Collaboratore a livello di sottoscrizione fornisce l'accesso necessario. Per altre informazioni sulle assegnazioni di ruolo, vedere Controllo degli accessi in base al ruolo in Azure.

5. Eseguire lo script

  1. Se non l'hai già fatto, accedi ad Azure usando l'Azure CLI.

    az login

  2. Eseguire lo script:

    python provision_blob.py

    Il completamento dello script richiede un minuto o due.

6: Verificare le risorse

  1. Aprire il portale di Azure per verificare che il gruppo di risorse e l'account di archiviazione siano stati creati come previsto. Potrebbe essere necessario attendere un minuto e selezionare Mostra tipi nascosti nel gruppo di risorse.

    Pagina del portale di Azure per il nuovo gruppo di risorse, che mostra l'account di archiviazione

  2. Selezionare l'account di archiviazione, quindi selezionareContenitori> dati nel menu a sinistra per verificare che venga visualizzato il messaggio "blob-container-01":

    Pagina del Portale di Azure per l'account di archiviazione che mostra il Blob Container

  3. Per provare a usare queste risorse dal codice dell'applicazione, continuare con Esempio: Usare Archiviazione di Azure.

Per un altro esempio di uso della libreria di gestione di Archiviazione di Azure, vedere l'esempio Gestire l'archiviazione Python.

7: Pulire le risorse

Lasciare invariate le risorse se si vuole seguire l'articolo Esempio: Usare Archiviazione di Azure per usare queste risorse nel codice dell'app. In caso contrario, eseguire il comando az group delete se non è necessario mantenere il gruppo di risorse e le risorse di archiviazione create in questo esempio.

I gruppi di risorse non comportano addebiti in corso nella sottoscrizione, ma le risorse, come gli account di archiviazione, nel gruppo di risorse potrebbero comportare addebiti. È consigliabile ripulire qualsiasi gruppo che non stai usando attivamente. L'argomento --no-wait consente al comando di restituire immediatamente il controllo invece di attendere il completamento dell'operazione.

#!/bin/bash
az group delete -n $AZURE_RESOURCE_GROUP_NAME --no-wait

Per riferimento: comandi equivalenti Azure CLI

I comandi dell'interfaccia della riga di comando di Azure seguenti completano gli stessi passaggi di creazione dello script Python:

#!/bin/bash
#!/bin/bash

# Set variables
export LOCATION=<Location> # Change to your preferred region
export AZURE_RESOURCE_GROUP_NAME=<ResourceGroupName> # Change to your preferred resource group name
export STORAGE_ACCOUNT_NAME=<StorageAccountName> # Change to your preferred storage account name
export CONTAINER_NAME=<ContainerName> # Change to your preferred container name

# Provision the resource group
echo "Creating resource group: $AZURE_RESOURCE_GROUP_NAME"
az group create \
    --location "$LOCATION" \
    --name "$AZURE_RESOURCE_GROUP_NAME"

# Provision the storage account
az storage account create -g $AZURE_RESOURCE_GROUP_NAME -l $LOCATION -n $STORAGE ACCOUNT_NAME --kind StorageV2 --sku Standard_LRS

echo Storage account name is $STORAGE_ACCOUNT_NAME

# Retrieve the connection string
CONNECTION_STRING=$(az storage account show-connection-string -g $AZURE_RESOURCE_GROUP_NAME -n $STORAGE_ACCOUNT_NAME --query connectionString)

# Provision the blob container
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --connection-string $CONNECTION_STRING

Vedere anche