Aggiungere un repository di artefatti a un lab

Questo articolo descrive come aggiungere un repository di artefatti al lab in Azure DevTest Labs. Gli artefatti sono strumenti o applicazioni da installare nelle macchine virtuali. Gli artefatti vengono definiti in un file JSON caricato da un repository GitHub o Azure Repos Git.

Il repository degli artefatti GitHub di DevTest Labs pubblico fornisce molti artefatti comuni per Windows e Linux. Gli artefatti in questo repository pubblico sono disponibili per impostazione predefinita in DevTest Labs. Per informazioni sull'aggiunta di artefatti alle macchine virtuali, vedere Aggiungere artefatti alle macchine virtuali di DevTest Labs.

È anche possibile creare artefatti personalizzati che non sono disponibili nel repository di artefatti pubblici. Per informazioni sulla creazione di artefatti personalizzati, vedere Creare artefatti personalizzati. È possibile aggiungere gli artefatti personalizzati al proprio repository di artefatti e aggiungere il repository al lab in modo che tutti gli utenti del lab possano usare gli artefatti.

Questo articolo illustra come aggiungere un repository di artefatti al lab usando il portale di Azure, un modello di Azure Resource Management (ARM) o Azure PowerShell. È anche possibile usare uno script di Azure PowerShell o dell'interfaccia della riga di comando di Azure per automatizzare l'aggiunta di un repository di artefatti a un lab.

Aggiungere un repository di artefatti

È possibile aggiungere un repository di artefatti da un repository Azure Repos o da un repository GitHub. È possibile scegliere di eseguire l'autenticazione assegnando autorizzazioni a un'identità gestita, usando l'autenticazione dell'app GitHub o usando un token di accesso personale. Per altre informazioni sulle identità gestite, vedere Informazioni sulle identità gestite per le risorse di Azure.

Selezionare la scheda per il tipo di repository e l'autenticazione da usare.

Aggiungere un repository di artefatti usando un modello di Resource Manager

I modelli arm sono file JSON che descrivono le risorse di Azure da creare. Per altre informazioni sui modelli di Resource Manager, vedere Comprendere la struttura e la sintassi dei modelli arm.

Il modello di Resource Manager seguente aggiunge un repository di artefatti a un lab. Il modello crea il lab, se non esiste già.

Esaminare il modello di ARM

Il modello di esempio raccoglie le informazioni seguenti nei parametri. Alcuni parametri hanno impostazioni predefinite, ma il comando di distribuzione deve specificare il nome del lab, l'URI del repository artefatto, il tipo di repository e il token di accesso personale del repository.

• Nome del lab.
• Nome visualizzato per il repository degli artefatti in DevTest Labs. Il valore predefinito è Team Repository.
• URI del repository di artefatti copiato in precedenza.
• Ramo del repository che contiene gli artefatti. Il valore predefinito è main.
• Nome della cartella che contiene gli artefatti. Il valore predefinito è: /Artifacts.
• Tipo di repository. I valori consentiti sono VsoGit, per Azure Repos o GitHub.
• Token di accesso personale per il repository copiato in precedenza.

{

    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "labName": {
            "type": "string"
        },
        "artifactRepositoryDisplayName": {
            "type": "string",
            "defaultValue": "Team Repository"
        },
        "artifactRepoUri": {
            "type": "string"
        },
        "artifactRepoBranch": {
            "type": "string",
            "defaultValue": "main"
        },
        "artifactRepoFolder": {
            "type": "string",
            "defaultValue": "/Artifacts"
        },
        "artifactRepoType": {
            "type": "string",
            "allowedValues": ["VsoGit", "GitHub"]
        },
        "artifactRepoSecurityToken": {
            "type": "securestring"
        }
    },
    "variables": {
        "artifactRepositoryName": "[concat('Repo-', uniqueString(subscription().subscriptionId))]"
    },
    "resources": [{
            "apiVersion": "2016-05-15",
            "type": "Microsoft.DevTestLab/labs",
            "name": "[parameters('labName')]",
            "location": "[resourceGroup().location]",
            "resources": [
                {
                    "apiVersion": "2016-05-15",
                    "name": "[variables('artifactRepositoryName')]",
                    "type": "artifactSources",
                    "dependsOn": [
                        "[resourceId('Microsoft.DevTestLab/labs', parameters('labName'))]"
                    ],
                    "properties": {
                        "uri": "[parameters('artifactRepoUri')]",
                        "folderPath": "[parameters('artifactRepoFolder')]",
                        "branchRef": "[parameters('artifactRepoBranch')]",
                        "displayName": "[parameters('artifactRepositoryDisplayName')]",
                        "securityToken": "[parameters('artifactRepoSecurityToken')]",
                        "sourceType": "[parameters('artifactRepoType')]",
                        "status": "Enabled"
                    }
                }
            ]
        }
    ]
}

Distribuire il modello

Esistono diversi modi per distribuire modelli di Resource Manager per creare o aggiornare le risorse di Azure. Per informazioni e istruzioni, vedere gli articoli seguenti:

• Distribuire le risorse con i modelli di Azure Resource Manager e Azure PowerShell
• Distribuire le risorse con i modelli di Azure Resource Manager e l'interfaccia della riga di comando di Azure
• Distribuire le risorse con i modelli di Resource Manager nel portale di Azure
• Distribuire le risorse con i modelli di Resource Manager e l'API REST di Resource Manager

Per questo esempio, distribuire il modello usando Azure PowerShell.

1. Creare un gruppo di risorse usando New-AzResourceGroup. Se il gruppo di risorse che si vuole usare esiste già, ignorare questo passaggio.

   New-AzResourceGroup -Name MyLabResourceGroup1 -Location westus
   

2. Creare una distribuzione nel gruppo di risorse usando New-AzResourceGroupDeployment. È possibile eseguire diverse distribuzioni di risorse nello stesso gruppo di risorse. Se si distribuisce più volte nello stesso gruppo di risorse, assicurarsi che ogni nome di distribuzione sia univoco.

   New-AzResourceGroupDeployment `
       -Name MyLabResourceGroup-Deployment1 `
       -ResourceGroupName MyLabResourceGroup1 `
       -TemplateFile azuredeploy.json `
       -TemplateParameterFile azuredeploy.parameters.json
   

Dopo New-AzResourceGroupDeployment l'esecuzione, l'output mostra informazioni importanti come lo stato di provisioning, che deve essere succeedede tutti gli output per il modello.

Aggiungere un repository di artefatti usando Azure PowerShell

Lo script di PowerShell di esempio seguente, New-DevTestLabArtifactRepository.ps1, aggiunge un repository di artefatti a un lab. Lo script completo include alcuni messaggi e commenti dettagliati.

<#

.SYNOPSIS
This script creates a new custom repository and adds it to an existing DevTest Lab.

.PARAMETER LabName
The name of the lab.

.PARAMETER LabResourceGroupName
The name of the resource group that contains the lab.

.PARAMETER ArtifactRepositoryName
Name for the new artifact repository. The script creates a random name for the repository if not specified.

.PARAMETER ArtifactRepositoryDisplayName
Display name for the artifact repository.
This name appears in the list of artifact repositories for a lab.

.PARAMETER RepositoryUri
Uri to the artifact repository.

.PARAMETER RepositoryBranch
Branch that contains the artifact files. Defaults to 'main'.

.PARAMETER FolderPath
Folder that contains the artifact files. Defaults to '/Artifacts'

.PARAMETER PersonalAccessToken
Personal access token for the GitHub or Azure Repos repository.

.PARAMETER SourceType
Whether the artifact repository is a VSOGit (Azure Repos) or GitHub repository.

.EXAMPLE
Set-AzContext -SubscriptionId aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e
.\New-DevTestLabArtifactRepository.ps1 -LabName "mydevtestlab" -LabResourceGroupName "mydtlrg" -ArtifactRepositoryName "MyTeam Repository" -RepositoryUri "https://github.com/<myteam>/<nameofrepo>.git" -PersonalAccessToken "1111...." -SourceType "GitHub"

.NOTES
The script uses the current Azure context. To set the context, use Set-AzContext.

#>


[CmdletBinding()]
Param(

    [Parameter(Mandatory=$true)]
    $LabName,

    [Parameter(Mandatory=$true)]
    $LabResourceGroupName,
    $ArtifactRepositoryName,
    $ArtifactRepositoryDisplayName  = 'Team Artifact Repository',

    [Parameter(Mandatory=$true)]
    $RepositoryUri,
    $RepositoryBranch = 'main',
    $FolderPath = '/Artifacts',

    [Parameter(Mandatory=$true)]
    $PersonalAccessToken ,

    [Parameter(Mandatory=$true)]
    [ValidateSet('VsoGit', 'GitHub')]
    $SourceType
)

# Set artifact repository internal name if not specified.

if ($ArtifactRepositoryName -eq $null){
    $ArtifactRepositoryName = "PrivateRepo" + (Get-Random -Maximum 999)
}

# Sign in to Azure.
Connect-AzAccount


#Get Lab Resource.
$LabResource = Get-AzResource -ResourceType 'Microsoft.DevTestLab/labs' -ResourceName $LabName -ResourceGroupName $LabResourceGroupName

Write-Verbose "Lab Name: $($LabResource.Name)"
Write-Verbose "Lab Resource Group Name: $($LabResource.ResourceGroupName)"
Write-Verbose "Lab Resource Location: $($LabResource.Location)"

Write-Verbose "Artifact Repository Internal Name: $ArtifactRepositoryName"

#Prepare properties object for the call to New-AzResource.
$propertiesObject = @{
    uri = $RepositoryUri;
    folderPath = $FolderPath;
    branchRef = $RepositoryBranch;
    displayName = $ArtifactRepositoryDisplayName;
    securityToken = $PersonalAccessToken;
    sourceType = $SourceType;
    status = 'Enabled'
}

Write-Verbose "Properties to be passed to New-AzResource:$($propertiesObject | Out-String)"

#Add resource to the current subscription.
$resourcetype = 'Microsoft.DevTestLab/labs/artifactSources'
$resourceName = $LabName + '/' + $ArtifactRepositoryName
Write-Verbose "Az ResourceType: $resourcetype"
Write-Verbose "Az ResourceName: $resourceName"

Write-Verbose "Creating artifact repository '$ArtifactRepositoryDisplayName'..."
$result = New-AzResource -Location $LabResource.Location -ResourceGroupName $LabResource.ResourceGroupName -properties $propertiesObject -ResourceType $resourcetype -ResourceName $resourceName -ApiVersion 2016-05-15 -Force

#Alternate implementation:
# Use resourceId rather than resourcetype and resourcename parameters.
# Using resourceId lets you specify the $SubscriptionId rather than using the
# subscription id of Get-AzContext.
#$resourceId = "/subscriptions/$SubscriptionId/resourceGroups/$($LabResource.ResourceGroupName)/providers/Microsoft.DevTestLab/labs/$LabName/artifactSources/$ArtifactRepositoryName"
#$result = New-AzResource -properties $propertiesObject -ResourceId $resourceId -ApiVersion 2016-05-15 -Force


# Check the result.
if ($result.Properties.ProvisioningState -eq "Succeeded") {
    Write-Verbose ("Successfully added artifact repository source '$ArtifactRepositoryDisplayName'")
}
else {
    Write-Error ("Error adding artifact repository source '$ArtifactRepositoryDisplayName'")
}

#Return the newly created resource to use in later scripts.
return $result

Parametri

Lo script di PowerShell accetta i parametri seguenti:

Il repository richiede un nome interno per l'identificazione, che è diverso dal nome visualizzato nel portale di Azure. Il nome interno non viene visualizzato quando si usa il portale di Azure, ma viene visualizzato quando si usano le API REST di Azure o Azure PowerShell. Lo script crea un nome casuale se il comando di distribuzione non ne specifica uno.

#Set artifact repository name, if not set by user
if ($ArtifactRepositoryName -eq $null){
    $ArtifactRepositoryName = "PrivateRepo" + (Get-Random -Maximum 999)
}

Comandi di PowerShell

Lo script usa i comandi di PowerShell seguenti:

Un buon modo per individuare il nome della risorsa e le informazioni sul tipo di risorsa consiste nell'usare il sito Web browser dell'API REST di Azure. DevTest Labs Artifact Sources (Origini artefatti di DevTest Labs) mostra le API REST per la creazione e la gestione delle origini degli artefatti di DevTest Labs. Lo script corrente usa l'ID risorsa seguente:

https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/artifactsources/{name}

Il tipo di risorsa è tutto quello elencato dopo providers nell'URI, ad eccezione degli elementi tra parentesi graffe. Il nome della risorsa è tutto racchiuso tra parentesi graffe. Se si usano più elementi per il nome della risorsa, separare ogni elemento con una barra:

$resourcetype = 'Microsoft.DevTestLab/labs/artifactSources'
$resourceName = $LabName + '/' + $ArtifactRepositoryName

Eseguire lo script di PowerShell

Eseguire lo script di PowerShell sostituendo i propri valori per i valori di esempio in LabName, RepositoryUriPersonalAccessTokenLabResourceGroupNameArtifactRepositoryNamee :SourceType

Set-AzContext -SubscriptionId <Your Azure subscription ID>

.\New-DevTestLabArtifactRepository.ps1 -LabName "mydevtestlab" -LabResourceGroupName "mydtlrg" -ArtifactRepositoryName "myteamrepository" -RepositoryUri "https://github.com/myteam/myteamrepository.git" - "1111...." -SourceType "GitHub"

Passaggi successivi

• Specificare gli artefatti obbligatori per le macchine virtuali di DevTest Labs
• Diagnosticare gli errori degli artefatti nel lab