Partager via

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

  • Article

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 bien démarrer, consultez Installer Azure PowerShell. Pour savoir comment migrer vers le module Az PowerShell, consultez Migrer Azure PowerShell depuis AzureRM vers Az.

Ajouter un référentiel d’artefact

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 en savoir plus sur les identités managées, consultez Que sont les identités managées pour les ressources Azure ?

Sélectionnez l’onglet correspondant au type de référentiel et d’authentification à utiliser.

Pour ajouter un référentiel d’artefact, effectuez les tâches suivantes :

  • Attribuez des autorisations dans Azure Repos pour l’identité managée.
  • Ajoutez votre référentiel d’artefact.

Attribuer des autorisations dans Azure Repos pour l’identité managée

Vous devez accorder à l’identité managée des autorisations sur le référentiel dans Azure Repos.

  1. Connectez-vous à votre organisation Azure DevOps.

    Remarque

    Votre organisation Azure DevOps doit se trouver dans le même répertoire que l’abonnement Azure qui contient votre labo.

  2. Sélectionnez Paramètres de l’organisation.

    Capture d’écran montrant la page Organisation Azure DevOps, avec Paramètres de l’organisation mis en surbrillance.

  3. Dans la page Vue d’ensemble, sélectionnez Utilisateurs.

    Capture d’écran montrant la page Vue d’ensemble de l’organisation, avec Utilisateurs mis en surbrillance.

  4. Dans la page Utilisateurs, sélectionnez Ajouter des utilisateurs.

    Capture d’écran montrant la page Utilisateurs, avec l’option Ajouter un utilisateur mis en surbrillance.

  5. Terminez Ajouter de nouveaux utilisateurs en entrant ou en sélectionnant les informations suivantes, puis sélectionnez Ajouter :

    Nom Valeur
    Utilisateurs ou principaux de service Entrez le nom de votre lab.
    Quand vous utilisez une identité MSI affectée par le système, spécifiez le nom du labo, et non l’ID d’objet du compte managé. Quand vous utilisez une identité MSI affectée par l’utilisateur, utilisez le nom du compte managé.
    Niveau d’accès Sélectionnez De base.
    Ajouter aux projets Sélectionnez le projet qui contient votre référentiel.
    Groupes Azure DevOps Sélectionnez Lecteurs de projet.
    Envoyer des invitations par e-mail (aux utilisateurs uniquement) Désactivez la case à cocher.

    Capture d’écran montrant Ajouter des utilisateurs, avec des exemples d’entrées et Ajouter mis en surbrillance.

Ajouter un référentiel d’artefact Azure DevOps à un labo dans le Portail Azure

  1. Dans la page Vue d’ensemble du laboratoire, sélectionnez Configuration et stratégies dans le volet de navigation de gauche.

  2. 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.

  3. Pour ajouter votre référentiel d’artefacts au laboratoire, sélectionnez Ajouter dans la barre de menu supérieure.

    Capture d’écran montrant l’écran de configuration des référentiels.

  4. 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 à partir d’Azure Repos.
    • Branche (facultatif) : branche qui contient vos définitions d’artefacts.
    • 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.
    • Identité managée : utilisez cette option pour tirer profit de l’identité managée pour l’authentification.

  5. Cliquez sur Enregistrer.

    Capture d’écran montrant l’ajout d’un nouveau référentiel d’artefacts dans un labo.

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.

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

Étapes suivantes