Een opslagplaats voor artefacten toevoegen aan een lab

  • Artikel

In dit artikel wordt uitgelegd hoe u een opslagplaats voor artefacten toevoegt aan uw lab in Azure DevTest Labs. Artefacten zijn hulpprogramma's of toepassingen die moeten worden geïnstalleerd op virtuele machines (VM's). U definieert artefacten in een JSON-bestand dat u laadt vanuit een GitHub- of Azure-opslagplaats.

De openbare GitHub-artefactopslagplaats van DevTest Labs biedt veel algemene artefacten voor Windows en Linux. De artefacten in deze openbare opslagplaats zijn standaard beschikbaar in DevTest Labs. Zie Artefacten toevoegen aan DevTest Labs-VM's voor meer informatie over het toevoegen van artefacten aan VM's.

U kunt ook aangepaste artefacten maken die niet beschikbaar zijn in de opslagplaats voor openbare artefacten. Zie Aangepaste artefacten maken voor meer informatie over het maken van aangepaste artefacten. U kunt uw aangepaste artefacten toevoegen aan uw eigen artefactopslagplaats en de opslagplaats toevoegen aan uw lab, zodat alle labgebruikers de artefacten kunnen gebruiken.

In dit artikel wordt beschreven hoe u een opslagplaats voor artefacten aan uw lab toevoegt met behulp van de Azure Portal, een ARM-sjabloon (Azure Resource Management) of Azure PowerShell. U kunt ook een Azure PowerShell- of Azure CLI-script gebruiken om het toevoegen van een artefactopslagplaats aan een lab te automatiseren.

Notitie

U wordt aangeraden de Azure Az PowerShell-module te gebruiken om te communiceren met Azure. Zie Azure PowerShell installeren om aan de slag te gaan. Raadpleeg Azure PowerShell migreren van AzureRM naar Az om te leren hoe u naar de Azure PowerShell-module migreert.

Vereisten

Als u een opslagplaats voor artefacten wilt toevoegen aan een lab, moet u de GIT HTTPS-kloon-URL en het persoonlijke toegangstoken weten voor de GitHub- of Azure-opslagplaats met de artefactbestanden.

De kloon-URL en het persoonlijke toegangstoken voor GitHub ophalen

  1. Selecteer code op de startpagina van de GitHub-opslagplaats met uw artefacten en kopieer onder Klonen de HTTPS-URL.
  2. Selecteer uw profielafbeelding in de rechterbovenhoek van GitHub en selecteer vervolgens Instellingen.
  3. Selecteer op uw profielpagina in het linkermenu Instellingen voor ontwikkelaars en selecteer vervolgens Persoonlijke toegangstokens.
  4. Selecteer Nieuw token genereren.
  5. Voer op de pagina Nieuw persoonlijk toegangstoken onder Opmerking een optionele beschrijving in voor het token. Accepteer alle standaardwaarden en selecteer vervolgens Token genereren.
  6. Sla het gegenereerde token op.

De kloon-URL en het persoonlijke toegangstoken voor Azure-opslagplaatsen ophalen

  1. Selecteer Klonen op de hoofdpagina van de opslagplaats met uw artefacten. Kopieer op de pagina Opslagplaats klonen de kloon-URL.
  2. Selecteer in de rechterbovenhoek van de pagina Azure DevOps de optie Gebruikersinstellingen>Persoonlijke toegangstokens.
  3. Selecteer op de pagina Persoonlijke toegangstokensde optie Nieuw token.
  4. Vul de gegevens voor het token in, selecteer Lezen voor de bereiken en selecteer vervolgens Maken.
  5. Op de pagina Geslaagd kopieert u het token, omdat azure-opslagplaatsen het token niet opslaat of opnieuw weergeeft.

Een opslagplaats voor artefacten toevoegen aan een lab in de Azure Portal

  1. Selecteer op de pagina Overzicht van het lab De optie Configuratie en beleid in het linkernavigatievenster.

  2. Selecteer op de pagina Configuratie en beleidde optie Opslagplaatsen onder Externe resources in de linkernavigatiebalk.

    Op de pagina Opslagplaatsen is de opslagplaats voor openbare artefacten automatisch aanwezig en maakt deze verbinding met de openbare GitHub-opslagplaats van DevTest Labs. Als deze opslagplaats niet is ingeschakeld voor uw lab, kunt u deze inschakelen door het selectievakje naast Openbare artefactopslagplaats in te schakelen en vervolgens Inschakelen te selecteren in de bovenste menubalk.

  3. Als u uw artefactopslagplaats wilt toevoegen aan het lab, selecteert u Toevoegen in de bovenste menubalk.

    Schermopname van het configuratiescherm Opslagplaatsen.

  4. Voer in het deelvenster Opslagplaats de volgende gegevens in:

    • Naam: een opslagplaatsnaam die in het lab moet worden gebruikt.
    • Git-kloon-URL: de Git HTTPS-kloon-URL van GitHub of Azure-opslagplaatsen.
    • Vertakking (optioneel): de vertakking met uw artefactdefinities.
    • Persoonlijk toegangstoken: het persoonlijke toegangstoken van GitHub of Azure-opslagplaatsen.
    • Mappaden: de map voor uw ARM-sjabloondefinities, ten opzichte van de Git-kloon-URL. Zorg ervoor dat u de eerste slash in het mappad opneemt.

  5. Selecteer Opslaan.

    Schermopname van het toevoegen van een nieuwe artefactopslagplaats aan een lab.

De opslagplaats wordt nu weergegeven in de lijst Opslagplaatsen voor het lab.

Een artefactopslagplaats toevoegen met behulp van een ARM-sjabloon

ARM-sjablonen zijn JSON-bestanden waarin Azure-resources worden beschreven die moeten worden gemaakt. Zie Inzicht in de structuur en syntaxis van ARM-sjablonen voor meer informatie over ARM-sjablonen.

Met de volgende ARM-sjabloon wordt een opslagplaats voor artefacten toegevoegd aan een lab. De sjabloon maakt het lab als deze nog niet bestaat.

De ARM-sjabloon controleren

De voorbeeldsjabloon verzamelt de volgende informatie in parameters. Sommige parameters hebben standaardwaarden, maar de implementatieopdracht moet de labnaam, de URI van de artefactopslagplaats, het type opslagplaats en het persoonlijke toegangstoken voor de opslagplaats opgeven.

  • Labnaam.
  • Weergavenaam voor de artefactopslagplaats in DevTest Labs. De standaardwaarde is Team Repository.
  • URI van de artefactopslagplaats, die u eerder hebt gekopieerd.
  • Opslagplaatsbranch die de artefacten bevat. De standaardwaarde is main.
  • Naam van de map met de artefacten. De standaardwaarde is: /Artifacts.
  • Type opslagplaats. De toegestane waarden zijn VsoGit, voor Azure-opslagplaatsen of GitHub.
  • Persoonlijk toegangstoken voor de opslagplaats, dat u eerder hebt gekopieerd.
{

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

De sjabloon implementeren

Er zijn verschillende manieren om ARM-sjablonen te implementeren om Azure-resources te maken of bij te werken. Zie de volgende artikelen voor informatie en instructies:

In dit voorbeeld implementeert u de sjabloon met behulp van Azure PowerShell.

Notitie

De cmdlets waarmee de sjabloon wordt geïmplementeerd, zijn contextspecifiek, dus ze gebruiken de huidige tenant en het huidige abonnement. Als u de context wilt wijzigen, gebruikt u Set-AzContext voordat u de sjabloon implementeert

  1. Maak een resourcegroep met behulp van New-AzResourceGroup. Als de resourcegroep die u wilt gebruiken al bestaat, slaat u deze stap over.

    New-AzResourceGroup -Name MyLabResourceGroup1 -Location westus

  2. Maak een implementatie in de resourcegroep met behulp van New-AzResourceGroupDeployment. U kunt verschillende resource-implementaties maken in dezelfde resourcegroep. Als u meerdere keren implementeert in dezelfde resourcegroep, moet u ervoor zorgen dat elke implementatienaam uniek is.

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

Nadat New-AzResourceGroupDeployment de uitvoering is geslaagd, toont de uitvoer belangrijke informatie, zoals de inrichtingsstatus, die moet zijn succeeded, en eventuele uitvoer voor de sjabloon.

Een opslagplaats voor artefacten toevoegen met behulp van Azure PowerShell

Met het volgende PowerShell-voorbeeldscript ,New-DevTestLabArtifactRepository.ps1, wordt een opslagplaats voor artefacten toegevoegd aan een lab. Het volledige script bevat een aantal uitgebreide berichten en opmerkingen.


<#

.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 11111111-1111-1111-1111-111111111111
.\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

Parameters

Voor het PowerShell-script worden de volgende parameters gebruikt:

Parameter Beschrijving
LabName De naam van het lab.
ArtifactRepositoryName Naam voor de nieuwe artefactopslagplaats. Het script maakt een willekeurige naam voor de opslagplaats als deze niet is opgegeven.
ArtifactRepositoryDisplayName Weergavenaam die wordt weergegeven in de lijst met artefactopslagplaats van het lab.
RepositoryUri URI van de artefactopslagplaats, die u eerder hebt gekopieerd.
RepositoryBranch Opslagplaatsbranch die de artefacten bevat. De standaardwaarde is main.
FolderPath Map die de artefacten bevat. De standaardwaarde is: /Artifacts.
PersonalAccessToken Beveiligingstoken voor toegang tot de opslagplaats, die u eerder hebt gekopieerd.
SourceType Of de opslagplaats voor artefacten een VSOGit-opslagplaats (Azure-opslagplaatsen) of GitHub-opslagplaats is.

De opslagplaats heeft een interne naam nodig voor identificatie, die anders is dan de weergavenaam in de Azure Portal. U ziet de interne naam niet wanneer u de Azure Portal gebruikt, maar u ziet deze wel wanneer u Azure REST API's of Azure PowerShell gebruikt. Het script maakt een willekeurige naam als de implementatieopdracht er geen opgeeft.

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

PowerShell-opdrachten

Het script maakt gebruik van de volgende PowerShell-opdrachten:

Opdracht Opmerkingen
Get-AzResource Hiermee haalt u details op over het lab, zoals de locatie. U maakt de bron van de artefactopslagplaats op dezelfde locatie en onder dezelfde resourcegroep als het lab.
New-AzResource Voegt de Azure-resource toe. Er is geen specifieke opdracht voor het toevoegen van artefactopslagplaatsen. Deze cmdlet heeft het ResourceId of het ResourceName en-paar ResourceType nodig om te weten welk type resource moet worden gemaakt. Het huidige script maakt gebruik van het ResourceName paar en ResourceType .

Een goede manier om informatie over de resourcenaam en het resourcetype te vinden, is door de azure REST API Browser-website te gebruiken. DevTest Labs Artifact Sources toont REST API's voor het maken en beheren van DevTest Labs-artefactbronnen. Het huidige script gebruikt de volgende resource-id:

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

Het resourcetype is alles na providers in de URI, met uitzondering van items tussen accolades. De resourcenaam staat tussen de accolades. Als u meer dan één item gebruikt voor de resourcenaam, scheidt u elk item met een schuine streep:

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

Het PowerShell-script uitvoeren

Voer het PowerShell-script uit, waarbij u uw eigen waarden vervangt door de voorbeeldwaarden in LabName, LabResourceGroupNameArtifactRepositoryName, , RepositoryUri, PersonalAccessTokenen 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"

Volgende stappen