Hinzufügen eines Artefaktrepositorys zu einem Lab

In diesem Artikel wird beschrieben, wie Sie Ihrem Labor in Azure DevTest Labs ein Artefakt-Repository hinzufügen. Artsfakte sind Tools oder Anwendungen, die auf virtuellen Computern (VMs) installiert werden sollen. Sie definieren Artefakte in einer JSON-Datei, die Sie aus einem GitHub- oder Azure Repos-Git-Repository laden.

Das öffentliche DevTest Labs GitHub-Artefaktrepository bietet viele allgemeine Artefakte für Windows und Linux. Die Artefakte in diesem öffentlichen Repository sind standardmäßig in DevTest Labs verfügbar. Informationen zum Hinzufügen von Artefakten zu VMs finden Sie unter Hinzufügen von Artefakten zu DevTest Labs-VMs.

Sie können auch benutzerdefinierte Artefakte erstellen, die im öffentlichen Artefaktrepository nicht verfügbar sind. Informationen zum Erstellen benutzerdefinierter Artefakte finden Sie unter Erstellen benutzerdefinierter Artefakte. Sie können Ihre benutzerdefinierten Artefakte Ihrem eigenen Artefaktrepository und das Repository Ihrem Lab hinzufügen, damit alle Labbenutzer die Artefakte verwenden können.

In diesem Artikel wird gezeigt, wie Sie Ihrem Labor mithilfe des Azure-Portals, einer Arm-Vorlage (Azure Resource Management) oder Azure PowerShell ein Artefakt-Repository hinzufügen. Sie können auch ein Azure PowerShell- oder Azure CLI-Skript verwenden, um das Hinzufügen eines Artefaktrepositorys zu einem Lab zu automatisieren.

Hinzufügen eines Artefakt-Repositorys mithilfe des Azure-Portals

Sie können ein Artefaktrepository aus einem Azure Repos-Repository oder aus einem GitHub-Repository hinzufügen. Sie können sich authentifizieren, indem Sie einer verwalteten Identität Berechtigungen zuweisen oder indem Sie die GitHub-App-Authentifizierung oder ein PAT verwenden. Weitere Informationen zu verwalteten Identitäten finden Sie unter Was sind verwaltete Identitäten für Azure-Ressourcen?.

Wählen Sie die Registerkarte für den Typ des Repositorys und der Authentifizierung aus, die Sie verwenden möchten.

Hinzufügen eines Artefaktrepositorys mithilfe einer ARM-Vorlage

ARM-Vorlagen sind JSON-Dateien, die zu erstellende Azure-Ressourcen beschreiben. Weitere Informationen zu ARM-Vorlagen finden Sie unter Verstehen der Struktur und Syntax von ARM-Vorlagen.

Die folgende ARM-Vorlage fügt einem Lab ein Artefaktrepository hinzu. Wenn das Labor noch nicht vorhanden ist, erstellt die Vorlage es.

Überprüfen der ARM-Vorlage

Die Beispielvorlage sammelt die folgenden Informationen in Parametern. Einige Parameter haben Standardwerte, aber der Bereitstellungsbefehl muss den Labnamen, den Artefaktrepository-URI, den Repositorytyp und das persönliche Zugriffstoken des Repositorys angeben.

• Lab name.
• Der Anzeigename für das Artefaktrepository in DevTest Labs. Standardwert: Team Repository.
• URI des Artefaktrepositorys, das Sie zuvor kopiert haben.
• Repositorybranch, der die Artefakte enthält. Standardwert: main.
• Name des Ordners mit den Artefakten. Standardwert: /Artifacts.
• Repository type. Die zulässigen Werte sind VsoGit für Azure Repos oder GitHub.
• Persönliches Zugriffstoken für das Repository, das Sie zuvor kopiert haben.

{

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

Bereitstellen der Vorlage

Es gibt mehrere Möglichkeiten zum Bereitstellen von ARM-Vorlagen zum Erstellen oder Aktualisieren von Azure-Ressourcen. Informationen und Anweisungen finden Sie in den folgenden Artikeln:

• Bereitstellen von Ressourcen mit ARM-Vorlagen und Azure PowerShell
• Bereitstellen von Ressourcen mit ARM-Vorlagen und der Azure CLI
• Bereitstellen von Ressourcen mit ARM-Vorlagen und dem Azure-Portal
• Bereitstellen von Ressourcen mit ARM-Vorlagen und Resource Manager-REST-API

Stellen Sie für dieses Verfahren die Vorlage mithilfe von Azure PowerShell bereit.

1. Erstellen Sie eine Ressourcengruppe mithilfe von New-AzResourceGroup. Ist die Ressourcengruppe, die Sie verwenden möchten, bereits vorhanden, überspringen Sie diesen Schritt.

   New-AzResourceGroup -Name MyLabResourceGroup1 -Location westus
   

2. Erstellen Sie mit New-AzResourceGroupDeployment eine Bereitstellung für die Ressourcengruppe. Sie können mehrere Ressourcenbereitstellungen für dieselbe Ressourcengruppe durchführen. Falls Sie mehrere Bereitstellungen für dieselbe Ressourcengruppe durchführen, achten Sie darauf, dass der Name jeder Bereitstellung eindeutig ist.

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

Nachdem New-AzResourceGroupDeployment erfolgreich ausgeführt wurde, zeigt die Ausgabe wichtige Informationen wie den Bereitstellungsstatus an, der succeeded sein sollte, und alle Ausgaben für die Vorlage.

Hinzufügen eines Artefaktrepositorys mit Azure PowerShell

Das folgende PowerShell-Beispielskript, New-DevTestLabArtifactRepository.ps1, fügt einem Lab ein Artefaktrepository hinzu. Das vollständige Skript enthält einige ausführliche Meldungen und Kommentare.

<#

.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

Dem PowerShell-Skript werden die folgenden Parameter übergeben:

Das Repository benötigt einen internen Namen für die Identifizierung. Dieser Name unterscheidet sich vom Anzeigenamen im Azure-Portal. Der interne Name wird bei Verwendung von Azure-REST-APIs oder Azure PowerShell angezeigt, nicht aber im Azure-Portal. Das Skript erstellt einen zufälligen Namen, wenn der Bereitstellungsbefehl keinen angibt.

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

PowerShell commands

Das Skript verwendet die folgenden PowerShell-Cmdlets:

Name und Typ der Ressource ermitteln Sie am besten über die Azure-REST-API-Browser-Website. DevTest Labs-Artefaktquellen zeigt REST-APIs zum Erstellen und Verwalten von DevTest Labs-Artefaktquellen an. Das vorherige Skript verwendet die folgende Ressourcen-ID:

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

Der Ressourcentyp ist alles, was nach providers in der URI aufgeführt ist, mit Ausnahme von Elementen in geschweiften Klammern ({}). Der Ressourcenname ist alles, was in den geschweiften Klammern angegeben ist. Wenn Sie mehrere Elemente für den Ressourcennamen verwenden, trennen Sie die Element durch einen Schrägstrich:

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

Ausführen des PowerShell-Skripts

Führen Sie das PowerShell-Skript aus, und ersetzen Sie dabei Ihre eigenen Werte durch die Beispielwerte in LabName, LabResourceGroupName, ArtifactRepositoryName, RepositoryUri, PersonalAccessToken und 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

• Angeben verbindlicher Artefakte für DevTest Labs-VMs
• Diagnostizieren von Artefaktfehlern im Lab