Partager via

Ajouter des artefacts aux machines virtuelles DevTest Labs

  • Article

Cet article explique comment ajouter des artefacts aux machines virtuelles Azure DevTest Labs. Les artefacts spécifient les actions à entreprendre pour provisionner une machine virtuelle, par exemple l’exécution de scripts Windows PowerShell, l’exécution de commandes Bash ou l’installation de logiciels. Vous pouvez utiliser des paramètres pour personnaliser les artefacts en fonction de vos propres besoins.

Les artefacts DevTest Labs peuvent provenir du dépôt Git DevTest Labs public ou de dépôts Git privés. Pour créer vos propres artefacts personnalisés et les stocker dans un dépôt, consultez Créer des artefacts personnalisés. Pour ajouter votre dépôt d’artefacts à un labo afin que les utilisateurs puissent accéder aux artefacts personnalisés, consultez Ajouter un dépôt d’artefacts à votre labo.

Les propriétaires de labos DevTest Labs peuvent spécifier les artefacts obligatoires à installer sur toutes les machines virtuelles de labo au moment de leur création. Pour plus d’informations, consultez Spécifier les artefacts obligatoires pour les machines virtuelles DevTest Labs.

Vous ne pouvez pas changer ou supprimer les artefacts obligatoires au moment de la création d’une machine virtuelle, mais vous pouvez ajouter les artefacts individuels disponibles. Cet article explique comment ajouter des artefacts disponibles aux machines virtuelles à l’aide du portail Azure ou d’Azure PowerShell.

Ajouter des artefacts aux machines virtuelles à partir du portail Azure

Vous pouvez ajouter des artefacts durant la création d’une machine virtuelle, ou les ajouter à des machines virtuelles de labo existantes.

Pour ajouter des artefacts durant la création d’une machine virtuelle :

  1. Dans la page d’accueil du labo, sélectionnez Ajouter.

  2. Dans la page Choisir une base, sélectionnez le type de machine virtuelle souhaité.

  3. Dans l’écran Créer une ressource de labo, sélectionnez Ajouter ou supprimer des artefacts.

  4. Dans la page Ajouter des artefacts, sélectionnez la flèche en regard de chaque artefact à ajouter à la machine virtuelle.

  5. Dans chaque volet Ajouter un artefact, entrez les valeurs de paramètre obligatoires et facultatives, puis sélectionnez OK. L’artefact s’affiche sous Artefacts sélectionnés, et le nombre d’artefacts configurés est mis à jour.

    Capture d’écran montrant l’ajout d’artefacts dans le volet Ajouter un artefact.

  6. Vous pouvez changer les artefacts après les avoir ajoutés.

    • Par défaut, les artefacts s’installent dans l’ordre dans lequel vous les ajoutez. Pour réorganiser l’ordre, sélectionnez les points de suspension ... en regard de l’artefact dans la liste Artefacts sélectionnés, puis sélectionnez Monter, Descendre, Déplacer vers le haut ou Déplacer vers le bas.
    • Pour modifier les paramètres de l’artefact, sélectionnez Modifier afin de rouvrir le volet Ajouter un artefact.
    • Pour supprimer l’artefact de la liste Artefacts sélectionnés, sélectionnez Supprimer.

  7. Une fois que vous avez fini d’ajouter et de réorganiser les artefacts, sélectionnez OK.

  8. L’écran Créer une ressource de labo montre le nombre d’artefacts ajoutés. Pour ajouter, modifier, réorganiser ou supprimer des artefacts avant de créer la machine virtuelle, sélectionnez à nouveau Ajouter ou supprimer des artefacts.

Une fois que vous avez créé la machine virtuelle, les artefacts installés s’affichent dans la page Artefacts de la machine virtuelle. Pour voir les détails relatifs à l’installation de chaque artefact, sélectionnez le nom de l’artefact.

Pour installer des artefacts sur une machine virtuelle existante :

  1. Dans la page d’accueil du labo, sélectionnez la machine virtuelle dans la liste Mes machines virtuelles.

  2. Dans la page Machine virtuelle, sélectionnez Artefacts dans la barre de menus supérieure ou dans le volet de navigation de gauche.

  3. Dans la page Artefacts, sélectionnez Appliquer des artefacts.

    Capture d'écran montrant le volet des artefacts pour un ordinateur virtuel existant.

  4. Dans la page Ajouter des artefacts, sélectionnez et configurez les artefacts de la même manière que pour une nouvelle machine virtuelle.

  5. Une fois que vous avez fini d’ajouter des artefacts, sélectionnez Installer. Les artefacts s’installent immédiatement sur la machine virtuelle.

Ajouter des artefacts aux machines virtuelles à l’aide d’Azure PowerShell

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.

Le script PowerShell suivant applique un artefact à une machine virtuelle à l’aide de l’applet de commande Invoke-AzResourceAction.

#Requires -Module Az.Resources

param
(
[Parameter(Mandatory=$true, HelpMessage="The ID of the subscription that contains the lab")]
   [string] $SubscriptionId,
[Parameter(Mandatory=$true, HelpMessage="The name of the lab that has the VM")]
   [string] $DevTestLabName,
[Parameter(Mandatory=$true, HelpMessage="The name of the VM")]
   [string] $VirtualMachineName,
[Parameter(Mandatory=$true, HelpMessage="The repository where the artifact is stored")]
   [string] $RepositoryName,
[Parameter(Mandatory=$true, HelpMessage="The artifact to apply to the VM")]
   [string] $ArtifactName,
[Parameter(ValueFromRemainingArguments=$true)]
   $Params
)

# Set the appropriate subscription
Set-AzContext -SubscriptionId $SubscriptionId | Out-Null
 
# Get the lab resource group name
$resourceGroupName = (Get-AzResource -ResourceType 'Microsoft.DevTestLab/labs' | Where-Object { $_.Name -eq $DevTestLabName}).ResourceGroupName
if ($resourceGroupName -eq $null) { throw "Unable to find lab $DevTestLabName in subscription $SubscriptionId." }

# Get the internal repository name
$repository = Get-AzResource -ResourceGroupName $resourceGroupName `
                    -ResourceType 'Microsoft.DevTestLab/labs/artifactsources' `
                    -ResourceName $DevTestLabName `
                    -ApiVersion 2016-05-15 `
                    | Where-Object { $RepositoryName -in ($_.Name, $_.Properties.displayName) } `
                    | Select-Object -First 1

if ($repository -eq $null) { "Unable to find repository $RepositoryName in lab $DevTestLabName." }

# Get the internal artifact name
$template = Get-AzResource -ResourceGroupName $resourceGroupName `
                -ResourceType "Microsoft.DevTestLab/labs/artifactSources/artifacts" `
                -ResourceName "$DevTestLabName/$($repository.Name)" `
                -ApiVersion 2016-05-15 `
                | Where-Object { $ArtifactName -in ($_.Name, $_.Properties.title) } `
                | Select-Object -First 1

if ($template -eq $null) { throw "Unable to find template $ArtifactName in lab $DevTestLabName." }

# Find the VM in Azure
$FullVMId = "/subscriptions/$SubscriptionId/resourceGroups/$resourceGroupName`
                /providers/Microsoft.DevTestLab/labs/$DevTestLabName/virtualmachines/$virtualMachineName"

$virtualMachine = Get-AzResource -ResourceId $FullVMId

# Generate the artifact id
$FullArtifactId = "/subscriptions/$SubscriptionId/resourceGroups/$resourceGroupName`
                        /providers/Microsoft.DevTestLab/labs/$DevTestLabName/artifactSources/$($repository.Name)`
                        /artifacts/$($template.Name)"

# Handle the input parameters to pass through
$artifactParameters = @()

# Fill the artifact parameter with the additional -param_ data and strip off the -param_
$Params | ForEach-Object {
   if ($_ -match '^-param_(.*)') {
      $name = $_ -replace '^-param_'
   } elseif ( $name ) {
      $artifactParameters += @{ "name" = "$name"; "value" = "$_" }
      $name = $null #reset name variable
   }
}

# Create a structure to pass the artifact data to the action

$prop = @{
artifacts = @(
    @{
        artifactId = $FullArtifactId
        parameters = $artifactParameters
    }
    )
}

# Apply the artifact
if ($virtualMachine -ne $null) {
   # Apply the artifact by name to the virtual machine
   $status = Invoke-AzResourceAction -Parameters $prop -ResourceId $virtualMachine.ResourceId -Action "applyArtifacts" -ApiVersion 2016-05-15 -Force
   if ($status.Status -eq 'Succeeded') {
      Write-Output "##[section] Successfully applied artifact: $ArtifactName to $VirtualMachineName"
   } else {
      Write-Error "##[error]Failed to apply artifact: $ArtifactName to $VirtualMachineName"
   }
} else {
   Write-Error "##[error]$VirtualMachine was not found in the DevTest Lab, unable to apply the artifact"
}

Étapes suivantes