Ajouter un référentiel d’artefacts à un laboratoire

Cet article explique comment ajouter un référentiel d’artefacts à votre laboratoire dans Azure DevTest Labs. Les artefacts sont des outils ou des applications à installer sur des machines virtuelles. Vous définissez les artefacts dans un fichier JSON que vous chargez depuis un référentiel GitHub ou Azure Repos Git.

Le référentiel d’artefacts DevTest Labs GitHub public fournit de nombreux artefacts courants pour Windows et Linux. Les artefacts de ce référentiel public sont disponibles par défaut dans DevTest Labs. Pour plus d’informations sur l’ajout d’artefacts à des machines virtuelles, consultez Ajouter des artefacts à des machines virtuelles DevTest Labs.

Vous pouvez également créer des artefacts personnalisés qui ne sont pas disponibles dans le référentiel d’artefacts public. Pour en savoir plus sur la création d’artefacts personnalisés, voir Create custom artefacts (Créer des artefacts personnalisés). Vous pouvez ajouter vos artefacts personnalisés à votre propre référentiel d’artefacts, puis ajouter ce référentiel à votre laboratoire afin que tous les utilisateurs du laboratoire puissent utiliser les artefacts.

Cet article explique comment ajouter un référentiel d’artefacts à votre laboratoire à l’aide du portail Azure, d’un modèle Azure Resource Management (ARM) ou d’Azure PowerShell. Vous pouvez également utiliser un script Azure PowerShell ou Azure CLI pour automatiser l’ajout d’un référentiel d’artefacts à un laboratoire.

Ajouter un référentiel d’artefacts à l’aide du portail Azure

Vous pouvez ajouter un référentiel d’artefact à partir d’un référentiel Azure Repos ou d’un référentiel GitHub. Vous pouvez choisir de vous authentifier en attribuant des autorisations à une identité managée en utilisant l’authentification d’application GitHub ou un jeton d’accès personnel (PAT). Pour plus d’informations sur les identités managées, consultez Que sont les identités managées pour les ressources Azure ?.

Sélectionnez l’onglet pour le type de référentiel et l’authentification que vous souhaitez utiliser.

Ajouter un référentiel d’artefacts à l’aide d’un modèle ARM

Les modèles ARM sont des fichiers JSON qui décrivent les ressources Azure à créer. Pour plus d’informations sur les modèles ARM, consultez Comprendre la structure et la syntaxe des modèles ARM.

Le modèle ARM suivant ajoute un référentiel d’artefacts à un laboratoire. Si le labo n’existe pas encore, le modèle le crée.

Examiner le modèle ARM

L’exemple de modèle rassemble les informations suivantes dans des paramètres. Certains des paramètres ont des valeurs par défaut, mais la commande de déploiement doit spécifier le nom du laboratoire, l’URI du référentiel d’artefacts, le type de référentiel et le jeton d’accès personnel du référentiel.

• Lab name.
• Nom d’affichage du référentiel d’artefacts dans DevTest Labs. La valeur par défaut est Team Repository.
• URI du référentiel d’artefacts que vous avez copié précédemment.
• Branche de référentiel qui contient les artefacts. La valeur par défaut est main.
• Nom du dossier contenant les artefacts. La valeur par défaut est /Artifacts.
• Repository type. Les valeurs autorisées sont VsoGit (pour Azure Repos) ou GitHub.
• Jeton d’accès personnel pour le référentiel, que vous avez copié précédemment.

{

    "$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"
                    }
                }
            ]
        }
    ]
}

Déployer le modèle

Il existe plusieurs façons de déployer des modèles ARM pour créer ou mettre à jour des ressources Azure. Pour obtenir des informations et des instructions, consultez les articles suivants :

• Déployer des ressources à l’aide de modèles Resource Manager et d’Azure PowerShell
• Déployer des ressources à l’aide de modèles Resource Manager et d’Azure CLI
• Déployer des ressources avec des modèles ARM dans le portail Azure
• Déployer des ressources avec des modèles Resource Manager et l’API REST Resource Manager

Pour cette procédure, déployez le modèle à l’aide d’Azure PowerShell.

1. Créez un groupe de ressources à l’aide de New-AzResourceGroup. Si le groupe de ressources que vous souhaitez utiliser existe déjà, ignorez cette étape.

   New-AzResourceGroup -Name MyLabResourceGroup1 -Location westus
   

2. Créez un déploiement sur le groupe de ressources à l’aide de New-AzResourceGroupDeployment. Vous pouvez effectuer plusieurs déploiements de ressources sur le même groupe de ressources. Si vous effectuez plusieurs déploiements sur le même groupe de ressources, assurez-vous que le nom de chaque déploiement est unique.

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

Une fois que New-AzResourceGroupDeployment s’est exécuté correctement, la sortie affiche des informations importantes comme l’état d’approvisionnement, qui doit être succeeded, et toutes les sorties du modèle.

Ajouter un référentiel d’artefacts à l’aide d’Azure PowerShell

L’exemple de script PowerShell suivant, New-DevTestLabArtifactRepository.ps1, ajoute un référentiel d’artefacts à un laboratoire. Le script complet comprend des commentaires et des messages détaillés.

<#

.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 a name isn't 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 it's 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

# Alternative 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

Parameters

Le script PowerShell utilise les paramètres suivants :

Le référentiel a besoin d’un nom interne pour l’identification. Ce nom est différent du nom complet dans le portail Azure. Le nom interne n’apparaît pas lorsque vous utilisez le portail Azure, mais vous le voyez lorsque vous utilisez les API REST Azure ou Azure PowerShell. Le script crée un nom aléatoire si la commande de déploiement n’en spécifie aucun.

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

PowerShell commands

Le script utilise les commandes PowerShell suivantes :

Un bon moyen de découvrir les informations sur le nom et le type de ressource est d’utiliser le site web Navigateur d’API REST Azure. DevTest Labs Artifact Sources présente les API REST pour la création et la gestion des sources d’artefacts DevTest Labs. Le script précédent utilise l’ID de ressource suivant :

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

Le type de ressource est tout indiqué après providers dans l’URI, à l’exception des éléments entre crochets ({}). Le nom de ressource est tout ce qui se trouve entre accolades. Si vous utilisez plusieurs éléments pour le nom de la ressource, séparez chaque élément par une barre oblique :

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

Exécution du script PowerShell

Exécutez le script PowerShell en substituant vos propres valeurs à celles de l’exemple dans LabName, LabResourceGroupName, ArtifactRepositoryName, RepositoryUri, PersonalAccessToken et 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"

Related content

• Spécifier les artefacts obligatoires pour les machines virtuelles DevTest Labs
• Diagnostiquer les échecs d’artefacts dans le labo