Aggiungere un repository di artefatti a un lab

Articolo
06/03/2024

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.

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 il repository GitHub o Azure Repos con i file di artefatto.

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

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

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

Nella pagina principale del repository con gli artefatti selezionare Clona. Nella pagina Clone Repository (Clona repository ) copiare l'URL clone.
Nell'angolo superiore destro della pagina Azure DevOps selezionare Impostazioni utente>Token di accesso personali.
Nella pagina Token di accesso personale selezionare Nuovo token.
Compilare le informazioni per il token, selezionare Leggi per gli ambiti e quindi selezionare Crea.
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

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

Nella pagina Repository il repository di artefatti pubblici è presente automaticamente 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 Public Artifact Repo e quindi selezionando Abilita nella barra dei menu in alto.
Per aggiungere il repository degli artefatti al lab, selezionare Aggiungi nella barra dei menu in alto.
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.
- Ramo (facoltativo): ramo con le definizioni degli artefatti.
- Token di accesso personale: token di accesso personale da GitHub o Azure Repos.
- Percorsi delle cartelle: la cartella per le definizioni del modello di Resource Manager rispetto all'URL clone Git. Assicurarsi di includere la barra iniziale nel percorso della cartella.
Seleziona Salva.

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

Nome 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:

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

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
```
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:

Parametro	Descrizione
`LabName`	Il nome del lab.
`ArtifactRepositoryName`	Nome del nuovo repository di artefatti. Lo script crea un nome casuale per il repository, se non è specificato.
`ArtifactRepositoryDisplayName`	Nome visualizzato visualizzato nell'elenco del repository degli artefatti del lab.
`RepositoryUri`	URI del repository di 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 artefatto nella stessa posizione e nello stesso gruppo di risorse del lab.
New-AzResource	Aggiunge la risorsa di Azure. Non esiste alcun comando specifico per l'aggiunta di repository di artefatti. Questo cmdlet deve avere o `ResourceId` o la `ResourceName` coppia e `ResourceType` per conoscere il tipo di risorsa da creare. 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 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"

Condividi tramite