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

Articolo
01/19/2024

Questo articolo illustra come usare le librerie di gestione di Azure in uno script Python per creare un gruppo di risorse contenente un account Archiviazione di Azure e un contenitore di archiviazione BLOB.

Dopo aver creato le risorse, vedere Esempio: Usare Archiviazione di Azure per usare le librerie client di Azure nel codice dell'applicazione Python per caricare un file nel contenitore di archiviazione BLOB.

Se non diversamente specificato, tutti i comandi di questo articolo funzionano allo stesso modo nella shell Bash Linux/macOS e nella shell dei comandi di Windows.

I comandi equivalenti dell'interfaccia della riga di comando di Azure 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. Di seguito sono riportate alcuni opzioni:

Configurare un ambiente virtuale Python usando o lo venv strumento preferito. È possibile creare l'ambiente virtuale in locale o in Azure Cloud Shell ed eseguire il codice. Assicurarsi di attivare l'ambiente virtuale per iniziare a usarlo.
Usare un ambiente conda.
Usare un contenitore di sviluppo in Visual Studio Code o GitHub Codespaces.

2: Installare i pacchetti di libreria di Azure necessari

Creare un file requirements.txt in cui elencare le librerie di gestione usate in questo esempio:
```
azure-mgmt-resource
azure-mgmt-storage
azure-identity
```
Nel terminale con l'ambiente virtuale attivato installare i requisiti:
```
pip install -r requirements.txt
```

3: Scrivere codice per creare risorse di archiviazione

Creare un file Python denominato provision_blob.py con il codice seguente. I commenti spiegano i dettagli. Lo script legge l'ID sottoscrizione da una variabile di ambiente, AZURE_SUBSCRIPTION_ID. Questa variabile viene impostata in un passaggio successivo. Il nome del gruppo di risorse, la posizione, il nome dell'account di archiviazione e il nome del contenitore sono tutti definiti come costanti nel codice.

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}")

Autenticazione nel codice

Più avanti in questo articolo si accede ad Azure con l'interfaccia della riga di comando di Azure per eseguire il codice di esempio. Se l'account dispone delle autorizzazioni per creare gruppi di risorse e risorse di archiviazione nella sottoscrizione di Azure, il codice verrà eseguito correttamente.

Per usare questo codice in uno script di produzione, è possibile impostare le variabili di ambiente per usare un metodo basato su entità servizio per l'autenticazione. Per altre informazioni, vedere Come autenticare le app Python con i servizi di Azure. È necessario assicurarsi che l'entità servizio disponga di autorizzazioni sufficienti per creare gruppi di risorse e risorse di archiviazione nella sottoscrizione assegnandole un ruolo appropriato in Azure, ad esempio il ruolo Collaboratore nella sottoscrizione.

Collegamenti di riferimento per le classi usate nel codice

4. Eseguire lo script

Se non è già stato fatto, accedere ad Azure usando l'interfaccia della riga di comando di Azure:
```
az login
```
Impostare la AZURE_SUBSCRIPTION_ID variabile di ambiente sull'ID sottoscrizione. È possibile eseguire il comando az account show e ottenere l'ID id sottoscrizione dalla proprietà nell'output:
- cmd
- bash
```
set AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
```
```
AZURE_SUBSCRIPTION_ID=00000000-0000-0000-0000-000000000000
```
Eseguire lo script:
```
python provision_blob.py
```

Il completamento dello script richiederà uno o due minuti.

5: Verificare le risorse

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.
Selezionare l'account di archiviazione, quindi selezionare Contenitori di archiviazione>dati nel menu a sinistra per verificare che venga visualizzato il messaggio "blob-container-01":
Per provare a usare queste risorse dal codice dell'applicazione, continuare con Esempio: Usare Archiviazione di Azure.

Per un altro esempio relativo all'uso della libreria di gestione di Archiviazione di Azure, vedere l'esempio di gestione dell'archiviazione in Python.

Per riferimento: comandi equivalenti dell'interfaccia della riga di comando di Azure

I comandi dell'interfaccia della riga di comando di Azure seguenti completano gli stessi passaggi di creazione dello 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: 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 pulire qualsiasi gruppo che non si usa attivamente. Con l'argomento --no-wait, il comando restituisce immediatamente il risultato invece di attendere il completamento dell'operazione.

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

Per eliminare un gruppo di risorse dal codice, è anche possibile usare il metodo ResourceManagementClient.resource_groups.begin_delete. Il codice in Esempio: Creare un gruppo di risorse illustra l'utilizzo.

Condividi tramite