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

Article
09/30/2023

Cet article vous 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 vous montre comment ajouter un référentiel d’artefacts à votre laboratoire en utilisant le portail Azure, un modèle Azure Resource Manager (ARM) ou 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.

Notes

Nous vous recommandons d’utiliser le module Azure Az PowerShell pour interagir avec Azure. Pour commencer, consultez Installer Azure PowerShell. Pour savoir comment migrer vers le module Az PowerShell, consultez Migrer Azure PowerShell depuis AzureRM vers Az.

Prérequis

Pour ajouter un référentiel d’artefacts à un laboratoire, vous devez connaître l’URL du clone HTTPS de Git et le jeton d’accès personnel pour le référentiel GitHub ou Azure Repos qui contient les fichiers d’artefacts.

Obtenir l’URL du clone et le jeton d’accès personnel pour GitHub

Sur la page d’accueil du référentiel GitHub qui contient vos artefacts, sélectionnez Code et, sous Clone, copiez l’URL HTTPS.
Sélectionnez votre image de profil dans le coin supérieur droit de GitHub, puis sélectionnez Paramètres.
Sur votre page de profil, dans le menu de gauche, sélectionnez Paramètres du développeur, puis sélectionnez Jetons d’accès personnels.
Sélectionnez Générer un nouveau jeton.
Dans la page Nouveau jeton d’accès personnel, sous Note, entrez une description facultative pour le jeton. Acceptez toutes les valeurs par défaut, puis sélectionnez Générer le jeton.
Enregistrez le jeton généré.

Obtenir l’URL du clone et le jeton d’accès personnel pour Azure Repos

Sur la page principale du référentiel qui contient vos artefacts, sélectionnez Clone. Dans la page Référentiel du clone, copiez l’URL du clone.
Dans le coin supérieur droit de la page Azure DevOps, sélectionnez Paramètres utilisateur>Jetons d’accès personnels.
Dans la page Jetons d’accès personnels, sélectionnez Nouveau jeton.
Renseignez les informations du jeton, en sélectionnant Lecture pour les étendues, puis sélectionnez Créer.
Sur la page Réussite, veillez à copier le jeton, car Azure Repos ne le stocke pas et ne l’affiche plus par la suite.

Ajouter un référentiel d’artefacts à un laboratoire dans le portail Azure

Dans la page Vue d’ensemble du laboratoire, sélectionnez Configuration et stratégies dans le volet de navigation de gauche.
Sur la page Configuration et stratégies, sélectionnez Référentiels sous Ressources externes dans le volet de navigation gauche.

Sur la page Référentiels, le référentiel d’artefacts public est automatiquement présent et se connecte au référentiel GitHub public de DevTest Labs. Si ce référentiel n’est pas activé pour votre laboratoire, vous pouvez l’activer en cochant la case à côté de Référentiel d’artefacts public, puis en sélectionnant Activer dans la barre de menu supérieure.
Pour ajouter votre référentiel d’artefacts au laboratoire, sélectionnez Ajouter dans la barre de menu supérieure.
Dans le volet Référentiel, entrez les informations suivantes :
- Nom : nom de référentiel à utiliser dans le laboratoire.
- URL du clone Git : URL du clone HTTPS Git de GitHub ou Azure Repos.
- Branche (facultatif) : branche qui contient vos définitions d’artefacts.
- Jeton d’accès personnel : jeton d’accès personnel de GitHub ou Azure Repos.
- Chemins d’accès aux dossiers : dossier de vos définitions de modèles ARM, relatif à l’URL du clone Git. Veillez à inclure la barre oblique initiale dans le chemin d’accès du dossier.
Sélectionnez Enregistrer.

Le référentiel s’affiche désormais dans la liste Référentiels du laboratoire.

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. Ce modèle crée le laboratoire, s’il n’existe pas déjà.

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.

Nom du laboratoire.
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.
Type de référentiel. 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 :

Pour cet exemple, déployez le modèle en utilisant Azure PowerShell.

Notes

Les cmdlets qui déploient le modèle sont spécifiques au contexte, elles utilisent donc le locataire et l’abonnement actuels. Si vous devez modifier le contexte, utilisez Set-AzContext avant de déployer le modèle.

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

Paramètres

Le script PowerShell utilise les paramètres suivants :

Paramètre	Description
`LabName`	Nom du lab.
`ArtifactRepositoryName`	Nom du nouveau référentiel d’artefacts. Le script crée un nom aléatoire pour le dépôt, s’il n’est pas spécifié.
`ArtifactRepositoryDisplayName`	Nom complet qui apparaît dans la liste des référentiels d’artefacts du laboratoire.
`RepositoryUri`	URI du référentiel d’artefacts que vous avez copié précédemment.
`RepositoryBranch`	Branche de référentiel qui contient les artefacts. La valeur par défaut est `main`.
`FolderPath`	Dossier qui contient les artefacts. La valeur par défaut est `/Artifacts`.
`PersonalAccessToken`	Jeton de sécurité pour accéder au référentiel, que vous avez copié précédemment.
`SourceType`	Indique si le référentiel d’artefacts est un référentiel VSOGit (Azure Repos) ou GitHub.

Le référentiel a besoin d’un nom interne pour l’identification, qui est différent du nom d’affichage 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 not set by user
if ($ArtifactRepositoryName -eq $null){
    $ArtifactRepositoryName = "PrivateRepo" + (Get-Random -Maximum 999)
}

Commandes PowerShell

Le script utilise les commandes PowerShell suivantes :

Commande	Notes
Get-AzResource	Obtient des détails sur le laboratoire, par exemple son emplacement. Vous créez la source du référentiel d’artefacts au même emplacement et sous le même groupe de ressources que le laboratoire.
New-AzResource	Ajoute la ressource Azure. Il n’existe aucune commande spécifique pour l’ajout de dépôts d’artefact. Cette cmdlet requiert la valeur `ResourceId` ou la paire de valeurs `ResourceName` et `ResourceType` pour connaître le type de ressource à créer. Le script actuel utilise la paire `ResourceName` et `ResourceType`.

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 actuel 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 ce qui est listé après providers dans l’URI, à l’exception des éléments entre accolades. 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"

Partage via