Avvio rapido: Definire e assegnare un progetto di Azure con l'interfaccia della riga di comando di Azure

Articolo
06/25/2024

Importante

L’11 luglio 2026, Blueprints (anteprima) sarà deprecato. Eseguire la migrazione delle definizioni e delle assegnazioni di progetto esistenti a specifiche di modello e stack di distribuzione. Gli artefatti del progetto devono essere convertiti in modelli JSON ARM o in file Bicep usati per definire gli stack di distribuzione. Per informazioni su come creare un artefatto come risorsa ARM, vedere:

In questa esercitazione viene descritto come usare Azure Blueprints per eseguire alcune della attività comuni di creazione, pubblicazione e assegnazione di un progetto all'interno dell'organizzazione. Questa competenza consente di definire modelli comuni per sviluppare configurazioni riutilizzabili e rapidamente distribuibili, basate su modelli, criteri e sicurezza di Azure Resource Manager (ARM).

Prerequisiti

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.
Se Azure Blueprints non è stato mai usato prima, registrare il provider di risorse tramite l'interfaccia della riga di comando di Azure con az provider register --namespace Microsoft.Blueprint.

Azure Cloud Shell

Azure Cloud Shell è un ambiente di shell interattivo ospitato in Azure e usato tramite il browser. È possibile usare Bash o PowerShell con Cloud Shell per usare i servizi di Azure. È possibile usare i comandi preinstallati di Cloud Shell per eseguire il codice contenuto in questo articolo senza dover installare strumenti nell'ambiente locale.

Per avviare Azure Cloud Shell:

Opzione	Esempio/Collegamento
Selezionare Prova nell'angolo superiore destro di un blocco di codice o di comando. Quando si seleziona Prova, il codice o il comando non viene copiato automaticamente in Cloud Shell.
Passare a https://shell.azure.com o selezionare il pulsante Avvia Cloud Shell per aprire Cloud Shell nel browser.
Selezionare il pulsante Cloud Shell nella barra dei menu nell'angolo in alto a destra del portale di Azure.

Per usare Azure Cloud Shell:

Avviare Cloud Shell.
Selezionare il pulsante Copia in un blocco di codice (o in un blocco di comando) per copiare il codice o il comando.
Incollare il codice o il comando nella sessione di Cloud Shell selezionando CTRL+MAIUSC+V in Windows e Linux o selezionando CMD+MAIUSC+V in macOS.
Premere Invio per eseguire il codice o il comando.

Aggiungere l'estensione Blueprint

Per abilitare l'interfaccia della riga di comando di Azure per gestire le definizioni e le assegnazioni del progetto, è necessario aggiungere l'estensione. Questa estensione funziona ovunque sia possibile usare l'interfaccia della riga di comando di Azure. Sono inclusi bash in Windows 10, Cloud Shell (sia la versione autonoma che quella all'interno del portale), l'immagine Docker dell'interfaccia della riga di comando di Azure o un'estensione installata localmente.

Controllare che sia installata l'interfaccia della riga di comando di Azure più recente o almeno la versione 2.0.76. Se non è ancora installato, seguire queste istruzioni.
iIportare l'estensione con il comando seguente nell'ambiente dell'interfaccia della riga di comando di Azure scelto:
```
# Add the Blueprint extension to the Azure CLI environment
az extension add --name blueprint
```

Verificare che l'estensione sia stata installata e che la versione sia quella prevista (almeno 0.1.0):

# Check the extension list (note that you might have other extensions installed)
az extension list

# Run help for extension options
az blueprint -h

Creare un progetto

Il primo passaggio nella definizione di un modello standard per la conformità è la creazione di un progetto dalle risorse disponibili. Verrà creato un progetto denominato MyBlueprint per configurare le assegnazioni di ruolo e di criteri per la sottoscrizione. Vengono quindi aggiunti un gruppo di risorse, un modello di Resource Manager e un'assegnazione di ruolo nel gruppo di risorse.

Nota

Quando si usa l'interfaccia della riga di comando di Azure, l'oggetto progetto viene creato per primo. Per ogni artefatto da aggiungere che include parametri, definire i parametri in anticipo nel progetto iniziale.

Creare l'oggetto progetto iniziale. Il parametro parameters accetta un file JSON che include tutti i parametri a livello di progetto. I parametri vengono impostati durante l'assegnazione e vengono usati dagli artefatti aggiunti nei passaggi successivi.

File JSON - blueprintparms.json

{
   "storageAccountType": {
       "type": "string",
       "defaultValue": "Standard_LRS",
       "allowedValues": [
           "Standard_LRS",
           "Standard_GRS",
           "Standard_ZRS",
           "Premium_LRS"
       ],
       "metadata": {
           "displayName": "storage account type.",
           "description": null
       }
   },
   "tagName": {
       "type": "string",
       "metadata": {
           "displayName": "The name of the tag to provide the policy assignment.",
           "description": null
       }
   },
   "tagValue": {
       "type": "string",
       "metadata": {
           "displayName": "The value of the tag to provide the policy assignment.",
           "description": null
       }
   },
   "contributors": {
       "type": "array",
       "metadata": {
           "description": "List of AAD object IDs that is assigned Contributor role at the subscription",
           "strongType": "PrincipalId"
       }
   },
   "owners": {
       "type": "array",
       "metadata": {
           "description": "List of AAD object IDs that is assigned Owner role at the resource group",
           "strongType": "PrincipalId"
       }
   }
}

Comando dell'interfaccia della riga di comando di Azure
```
# Login first with az login if not using Cloud Shell

# Create the blueprint object
az blueprint create \
   --name 'MyBlueprint' \
   --description 'This blueprint sets tag policy and role assignment on the subscription, creates a ResourceGroup, and deploys a resource template and role assignment to that ResourceGroup.' \
   --parameters blueprintparms.json
```
Nota

Usare il nome file blueprint.json quando si importano le definizioni di progetto. Questo nome file viene usato quando si chiama az blueprint import.

Per impostazione predefinita, l'oggetto progetto viene creato nella sottoscrizione predefinita. Per specificare il gruppo di gestione, usare il parametro managementgroup. Per specificare la sottoscrizione, usare il parametro subscription.

Aggiungere il gruppo di risorse per gli artefatti di archiviazione alla definizione.

az blueprint resource-group add \
   --blueprint-name 'MyBlueprint' \
   --artifact-name 'storageRG' \
   --description 'Contains the resource template deployment and a role assignment.'

Aggiungere un'assegnazione di ruolo alla sottoscrizione. Nell'esempio seguente vengono configurate le identità delle entità cui è concesso il ruolo specificato in base a un parametro impostato durante l'assegnazione del progetto. Questo esempio usa il ruolo predefinito Contributor con GUID di b24988ac-6180-42a0-ab88-20f7382dd24c.
```
az blueprint artifact role create \
   --blueprint-name 'MyBlueprint' \
   --artifact-name 'roleContributor' \
   --role-definition-id '/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c' \
   --principal-ids "[parameters('contributors')]"
```

Aggiungere un'assegnazione di criteri alla sottoscrizione. In questo esempio vengono usati i criteri predefiniti Apply tag and its default value to resource groups, con un GUID di 49c88fc8-6fd1-46fd-a676-f12d1d3a4c71.

File JSON - artifacts\policyTags.json

{
   "tagName": {
      "value": "[parameters('tagName')]"
   },
   "tagValue": {
      "value": "[parameters('tagValue')]"
   }
}

Comando dell'interfaccia della riga di comando di Azure

az blueprint artifact policy create \
   --blueprint-name 'MyBlueprint' \
   --artifact-name 'policyTags' \
   --policy-definition-id '/providers/Microsoft.Authorization/policyDefinitions/49c88fc8-6fd1-46fd-a676-f12d1d3a4c71' \
   --display-name 'Apply tag and its default value to resource groups' \
   --description 'Apply tag and its default value to resource groups' \
   --parameters artifacts\policyTags.json

Nota

Quando si usa az blueprint in un Mac, sostituire \ con / per i valori dei parametri che includono il percorso. In questo caso, il valore per parameters diventa artifacts/policyTags.json.

Aggiungere un'altra assegnazione di criteri per il tag di archiviazione (riutilizzando storageAccountType_ parameter) nella sottoscrizione. Questo elemento di assegnazione di criteri aggiuntivo indica che un parametro definito nel progetto può essere usato da più di un elemento. Nell'esempio si usa il storageAccountType per impostare un tag nel gruppo di risorse. Questo valore fornisce informazioni sull'account di archiviazione che viene creato nel passaggio successivo. In questo esempio vengono usati i criteri predefiniti Apply tag and its default value to resource groups, con un GUID di 49c88fc8-6fd1-46fd-a676-f12d1d3a4c71.
- File JSON - artifacts\policyStorageTags.json
```
{
   "tagName": {
      "value": "StorageType"
   },
   "tagValue": {
      "value": "[parameters('storageAccountType')]"
   }
}
```
- Comando dell'interfaccia della riga di comando di Azure
```
az blueprint artifact policy create \
   --blueprint-name 'MyBlueprint' \
   --artifact-name 'policyStorageTags' \
   --policy-definition-id '/providers/Microsoft.Authorization/policyDefinitions/49c88fc8-6fd1-46fd-a676-f12d1d3a4c71' \
   --display-name 'Apply storage tag to resource group' \
   --description 'Apply storage tag and the parameter also used by the template to resource groups' \
   --parameters artifacts\policyStorageTags.json
```
  Nota
  
  Quando si usa az blueprint in un Mac, sostituire \ con / per i valori dei parametri che includono il percorso. In questo caso, il valore per parameters diventa artifacts/policyStorageTags.json.

Aggiungere un modello nel gruppo di risorse. Il parametro template per un modello di Resource Manager include i normali componenti JSON del modello. Il modello riutilizza anche i parametri di progetto storageAccountType, tagName e tagValue passando ognuno al modello. I parametri del progetto sono disponibili nel modello usando il parametro parameters e all'interno del file JSON del modello in cui viene usata questa coppia chiave-valore per inserire il valore. I nomi dei parametri del progetto e del modello potrebbero essere gli stessi.

File JSON del modello di Resource Manager - artifacts\templateStorage.json

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "storageAccountTypeFromBP": {
            "type": "string",
            "metadata": {
                "description": "Storage Account type"
            }
        },
        "tagNameFromBP": {
            "type": "string",
            "defaultValue": "NotSet",
            "metadata": {
                "description": "Tag name from blueprint"
            }
        },
        "tagValueFromBP": {
            "type": "string",
            "defaultValue": "NotSet",
            "metadata": {
                "description": "Tag value from blueprint"
            }
        }
    },
    "variables": {
        "storageAccountName": "[concat(uniquestring(resourceGroup().id), 'standardsa')]"
    },
    "resources": [{
        "type": "Microsoft.Storage/storageAccounts",
        "name": "[variables('storageAccountName')]",
        "apiVersion": "2016-01-01",
        "tags": {
            "[parameters('tagNameFromBP')]": "[parameters('tagValueFromBP')]"
        },
        "location": "[resourceGroup().location]",
        "sku": {
            "name": "[parameters('storageAccountTypeFromBP')]"
        },
        "kind": "Storage",
        "properties": {}
    }],
    "outputs": {
        "storageAccountSku": {
            "type": "string",
            "value": "[variables('storageAccountName')]"
        }
    }
}

File JSON dei parametri del modello di Resource Manager - artifacts\templateStorageParams.json

{
   "storageAccountTypeFromBP": {
      "value": "[parameters('storageAccountType')]"
   },
   "tagNameFromBP": {
      "value": "[parameters('tagName')]"
   },
   "tagValueFromBP": {
      "value": "[parameters('tagValue')]"
   }
}

Comando dell'interfaccia della riga di comando di Azure
```
az blueprint artifact template create \
   --blueprint-name 'MyBlueprint' \
   --artifact-name 'templateStorage' \
   --template artifacts\templateStorage.json \
   --parameters artifacts\templateStorageParams.json \
   --resource-group-art 'storageRG'
```
Nota

Quando si usa az blueprint in un Mac, sostituire \ con / per i valori dei parametri che includono il percorso. In questo caso, il valore per template diventa artifacts/templateStorage.json, e parameters diventa artifacts/templateStorageParams.json.

Aggiungere un'assegnazione di ruolo nel gruppo di risorse. Analogamente all'immissione dell'assegnazione di ruolo precedente, l'esempio seguente usa l'identificatore della definizione per il ruolo Owner e fornisce un parametro diverso del progetto. Questo esempio usa il ruolo predefinito Owner con GUID di 8e3af657-a8ff-443c-a75c-2fe8c4bcb635.
```
az blueprint artifact role create \
   --blueprint-name 'MyBlueprint' \
   --artifact-name 'roleOwner' \
   --role-definition-id '/providers/Microsoft.Authorization/roleDefinitions/8e3af657-a8ff-443c-a75c-2fe8c4bcb635' \
   --principal-ids "[parameters('owners')]" \
   --resource-group-art 'storageRG'
```

Pubblicare un progetto

Dopo aver aggiunto gli artefatti al progetto, è possibile pubblicarlo. La pubblicazione rende disponibile il progetto per l'assegnazione a una sottoscrizione.

az blueprint publish --blueprint-name 'MyBlueprint' --version '{BlueprintVersion}'

Il valore per {BlueprintVersion} è una stringa di lettere, numeri e trattini (senza spazi o altri caratteri speciali). La lunghezza massima è 20 caratteri. Usare un nome univoco e informativo, ad esempio v20200605-135541.

Assegnare un progetto

Dopo aver pubblicato un progetto usando l'interfaccia della riga di comando di Azure, è assegnabile a una sottoscrizione. Assegnare il progetto creato a una delle sottoscrizioni nella gerarchia dei gruppi di gestione. Se il progetto viene salvato in una sottoscrizione, può essere assegnato solo a tale sottoscrizione. Il parametro blueprint-name specifica il progetto da assegnare. Per fornire i parametri name, location, identity, lock e blueprint, usare i parametri corrispondenti dell'interfaccia della riga di comando di Azure nel comando az blueprint assignment create oppure specificarli nel file JSON parametri.

Eseguire la distribuzione del progetto assegnandolo a una sottoscrizione. Poiché ai parametri contributors e owners è necessaria una matrice di objectIds delle entità a cui concedere l'assegnazione di ruolo, usare l’API Graph di Azure Active Directory per raccogliere il objectIds da usare nel parameters per i propri utenti, gruppi o entità servizio.
- File JSON - blueprintAssignment.json
```
{
   "storageAccountType": {
       "value": "Standard_GRS"
   },
   "tagName": {
       "value": "CostCenter"
   },
   "tagValue": {
       "value": "ContosoIT"
   },
   "contributors": {
       "value": [
           "7be2f100-3af5-4c15-bcb7-27ee43784a1f",
           "38833b56-194d-420b-90ce-cff578296714"
       ]
   },
   "owners": {
       "value": [
           "44254d2b-a0c7-405f-959c-f829ee31c2e7",
           "316deb5f-7187-4512-9dd4-21e7798b0ef9"
       ]
   }
}
```
- Comando dell'interfaccia della riga di comando di Azure
```
az blueprint assignment create \
   --name 'assignMyBlueprint' \
   --location 'westus' \
   --resource-group-value artifact_name=storageRG name=StorageAccount location=eastus \
   --parameters blueprintAssignment.json
```
- Identità gestita assegnata dall'utente
  
  L'assegnazione di un progetto può anche usare un'identità gestita assegnata dall'utente. In questo caso, il parametro identity-type è impostato su UserAssignede il parametro user-assigned-identities specifica l'identità. Sostituire {userIdentity} con il nome dell'identità gestita assegnata dall'utente.
```
az blueprint assignment create \
   --name 'assignMyBlueprint' \
   --location 'westus' \
   --identity-type UserAssigned \
   --user-assigned-identities {userIdentity} \
   --resource-group-value artifact_name=storageRG name=StorageAccount location=eastus \
   --parameters blueprintAssignment.json
```
  L'identità gestita assegnata dall'utente può trovarsi in qualsiasi sottoscrizione e gruppo di risorse per cui l'utente che assegna il progetto abbia le autorizzazioni.
  
  Importante
  
  Azure Blueprints non gestisce l'identità gestita assegnata dall'utente. Gli utenti sono responsabili dell'assegnazione di ruoli e autorizzazioni sufficienti, altrimenti l'assegnazione del progetto non riesce.

Pulire le risorse

È possibile rimuovere un progetto da una sottoscrizione. La rimozione viene spesso eseguita quando le risorse dell'elemento non sono più necessarie. Quando un progetto viene rimosso, gli elementi assegnati nell'ambito del progetto vengono mantenuti. Per rimuovere l'assegnazione di un progetto, usare il comando az blueprint assignment delete:

az blueprint assignment delete --name 'assignMyBlueprint'

Passaggi successivi

In questa guida di avvio rapido si è creato, assegnato e rimosso un progetto con l'interfaccia della riga di comando di Azure. Per altre informazioni su Azure Blueprints, passare all'articolo relativo al ciclo di vita di un progetto.

Informazioni sul ciclo di vita di un progetto

Condividi tramite