Aggiungere un repository di artefatti a un lab

  • Articolo

Questo articolo illustra 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 di 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 degli artefatti pubblici. Per informazioni sulla creazione di artefatti personalizzati, vedere Creare artefatti personalizzati. È possibile aggiungere gli artefatti personalizzati al repository degli 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 Azure PowerShell o dell'interfaccia della riga di comando di Azure per automatizzare l'aggiunta di un repository di artefatti a un lab.

Nota

È consigliabile usare il modulo Azure Az PowerShell per interagire con Azure. Per iniziare, vedere Installare Azure PowerShell. Per informazioni su come eseguire la migrazione al modulo AZ PowerShell, vedere Eseguire la migrazione di Azure PowerShell da AzureRM ad Az.

Prerequisiti

Per aggiungere un repository di artefatti a un lab, è necessario conoscere l'URL clone Git HTTPS e il token di accesso personale per GitHub o Azure Repos repository con i file di artefatti.

Ottenere l'URL clone e il token di accesso personale per GitHub

  1. Nella home page del repository GitHub con gli artefatti selezionare Codice e in Clona copiare l'URL HTTPS.
  2. Selezionare l'immagine del profilo nell'angolo superiore destro di GitHub e quindi selezionare Impostazioni.
  3. Nel menu a sinistra della pagina del profilo selezionare Impostazioni sviluppatore e quindi token di accesso personali.
  4. Selezionare Genera nuovo token.
  5. Nella pagina Nuovo token di accesso personale immettere una descrizione facoltativa per il token in Nota. Accettare tutte le impostazioni predefinite e quindi selezionare Genera token.
  6. Salvare il token generato.

Ottenere l'URL clone e il token di accesso personale per Azure Repos

  1. Nella pagina principale del repository con gli artefatti selezionare Clona. Nella pagina Clone Repository (Clona repository ) copiare l'URL clone.
  2. Nell'angolo superiore destro della pagina Azure DevOps selezionare Impostazioni> utenteToken di accesso personali.
  3. Nella pagina Token di accesso personale selezionare Nuovo token.
  4. Compilare le informazioni per il token, selezionare Leggi per gli ambiti e quindi selezionare Crea.
  5. Nella pagina Operazione riuscita assicurarsi di copiare il token, perché Azure Repos non archivia il token o lo visualizza di nuovo.

Aggiungere un repository di artefatti a un lab nel portale di Azure

  1. Nella pagina Panoramica del lab selezionare Configurazione e criteri nel riquadro di spostamento a sinistra.

  2. Nella pagina Configurazione e criteri selezionare Repository in Risorse esterne nel riquadro di spostamento a sinistra.

    Nella pagina Repository il repository di artefatti pubblici è automaticamente presente e si connette al repository GitHub pubblico di DevTest Labs. Se questo repository non è abilitato per il lab, è possibile abilitarlo selezionando la casella di controllo accanto a Repository artefatto pubblico e quindi selezionando Abilita nella barra dei menu in alto.

  3. Per aggiungere il repository degli artefatti al lab, selezionare Aggiungi nella barra dei menu superiore.

    Screenshot che mostra la schermata di configurazione Repository.

  4. Nel riquadro Repository immettere le informazioni seguenti:

    • Nome: nome del repository da usare nel lab.
    • URL clone Git: URL clone Git HTTPS da GitHub o Azure Repos.
    • Branch (facoltativo): ramo con le definizioni degli artefatti.
    • Token di accesso personale: token di accesso personale da GitHub o Azure Repos.
    • Percorsi cartella: cartella per le definizioni del modello di Resource Manager, in relazione all'URL di clonazione Git. Assicurarsi di includere la barra iniziale nel percorso della cartella.

  5. Selezionare Salva.

    Screenshot che mostra l'aggiunta di un nuovo repository di artefatti a un lab.

Il repository viene ora visualizzato nell'elenco Repository per il lab.

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 di Resource Manager.

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 Resource Manager

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 degli artefatti, il tipo di repository e il token di accesso personale del repository.

  • Nome lab.
  • Nome visualizzato per il repository di artefatti in DevTest Labs. Il valore predefinito è Team Repository.
  • URI del repository degli 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:

Per questo esempio, distribuire il modello usando Azure PowerShell.

Nota

I cmdlet che distribuiscono il modello sono specifici del contesto, quindi usano il tenant e la sottoscrizione correnti. Se è necessario modificare il contesto, usare Set-AzContext prima di distribuire il modello

  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, ad esempio lo stato di provisioning, che deve essere succeedede 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 11111111-1111-1111-1111-111111111111
.\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:

Parametro Descrizione
LabName Il nome del lab.
ArtifactRepositoryName Nome del nuovo repository di artefatti. Se non è specificato, lo script crea un nome casuale per il repository.
ArtifactRepositoryDisplayName Nome visualizzato nell'elenco del repository degli artefatti del lab.
RepositoryUri URI del repository degli artefatti copiato in precedenza.
RepositoryBranch Ramo del repository che contiene gli artefatti. Il valore predefinito è main.
FolderPath Cartella contenente gli artefatti. Il valore predefinito è: /Artifacts.
PersonalAccessToken Token di sicurezza per l'accesso al repository copiato in precedenza.
SourceType Indica se il repository degli artefatti è un repository VSOGit (Azure Repos) o GitHub.

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:

Comando Note
Get-AzResource Ottiene informazioni dettagliate sul lab, ad esempio la relativa posizione. Si crea l'origine del repository degli artefatti nella stessa posizione e nello stesso gruppo di risorse del lab.
New-AzResource Aggiunge la risorsa di Azure. Non è disponibile alcun comando specifico per l'aggiunta di repository di artefatti. Per conoscere il tipo di risorsa da creare, questo cmdlet richiede l'oggetto ResourceIdResourceName o o la coppia e ResourceType . Lo script corrente usa la ResourceName coppia e ResourceType .

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 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, LabResourceGroupName, ArtifactRepositoryName, RepositoryUri, PersonalAccessTokene 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