Lägga till ett artefaktcentrallager till ett labb

  • Artikel

Den här artikeln beskriver hur du lägger till en artefaktlagringsplats i ditt labb i Azure DevTest Labs. Artefakter är verktyg eller program som ska installeras på virtuella datorer (VM). Du definierar artefakter i en JSON-fil som du läser in från en GitHub- eller Azure Repos Git-lagringsplats.

Den offentliga GitHub-artefaktlagringsplatsen DevTest Labs innehåller många vanliga artefakter för Windows och Linux. Artefakterna i den här offentliga lagringsplatsen är tillgängliga som standard i DevTest Labs. Information om hur du lägger till artefakter i virtuella datorer finns i Lägga till artefakter till virtuella DevTest Labs-datorer.

Du kan också skapa anpassade artefakter som inte är tillgängliga i den offentliga artefaktlagringsplatsen. Mer information om hur du skapar anpassade artefakter finns i Skapa anpassade artefakter. Du kan lägga till dina anpassade artefakter i din egen artefaktlagringsplats och lägga till lagringsplatsen i labbet så att alla labbanvändare kan använda artefakterna.

Den här artikeln visar hur du lägger till en artefaktlagringsplats i ditt labb med hjälp av Azure Portal, en ARM-mall (Azure Resource Management) eller Azure PowerShell. Du kan också använda ett Azure PowerShell- eller Azure CLI-skript för att automatisera tillägg av en artefaktlagringsplats i ett labb.

Anteckning

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Se Installera Azure PowerShell för att komma igång. Information om hur du migrerar till Az PowerShell-modulen finns i artikeln om att migrera Azure PowerShell från AzureRM till Az.

Förutsättningar

Om du vill lägga till en artefaktlagringsplats i ett labb behöver du känna till URL:en för Git HTTPS-klonen och den personliga åtkomsttoken för GitHub- eller Azure Repos-lagringsplatsen som innehåller artefaktfilerna.

Hämta klon-URL:en och personlig åtkomsttoken för GitHub

  1. På startsidan för GitHub-lagringsplatsen som innehåller dina artefakter väljer du Kod. Under Klona kopierar du HTTPS-URL:en.
  2. Välj din profilbild i det övre högra hörnet av GitHub och välj sedan Inställningar.
  3. På din profilsida går du till den vänstra menyn och väljer Utvecklarinställningar och sedan Personliga åtkomsttoken.
  4. Välj Generera ny token.
  5. På sidan Ny personlig åtkomsttoken , under Obs, anger du en valfri beskrivning för token. Acceptera alla standardvärden och välj sedan Generera token.
  6. Spara den genererade token.

Hämta klon-URL:en och personlig åtkomsttoken för Azure Repos

  1. På huvudsidan för lagringsplatsen som innehåller dina artefakter väljer du Klona. På sidan Klona lagringsplats kopierar du klon-URL:en.
  2. I det övre högra hörnet på sidan Azure DevOps väljer du Användarinställningar>Personliga åtkomsttoken.
  3. På sidan Personliga åtkomsttoken väljer du Ny token.
  4. Fyll i informationen för token, välj Läs för omfången och välj sedan Skapa.
  5. På sidan Lyckades måste du kopiera token eftersom Azure Repos inte lagrar token eller visar den igen.

Lägga till en artefaktlagringsplats i ett labb i Azure Portal

  1. På sidan Översikt för labbet väljer du Konfiguration och principer i det vänstra navigeringsfönstret.

  2. På sidan Konfiguration och principer väljer du Lagringsplatser under Externa resurser i det vänstra navigeringsfönstret.

    På sidan Lagringsplatser visas den offentliga artefaktlagringsplatsen automatiskt och ansluter till den offentliga GitHub-lagringsplatsen för DevTest Labs. Om den här lagringsplatsen inte är aktiverad för labbet kan du aktivera den genom att markera kryssrutan bredvid Lagringsplats för offentlig artefakt och sedan välja Aktivera på den översta menyraden.

  3. Om du vill lägga till artefaktlagringsplatsen i labbet väljer du Lägg till på den översta menyraden.

    Skärmbild som visar konfigurationsskärmen för lagringsplatser.

  4. I fönstret Lagringsplats anger du följande information:

    • Namn: Ett lagringsplatsnamn som ska användas i labbet.
    • URL för Git-klon: URL:en för Git HTTPS-klonen från GitHub eller Azure Repos.
    • Gren (valfritt): Grenen som har dina artefaktdefinitioner.
    • Personlig åtkomsttoken: Den personliga åtkomsttoken från GitHub eller Azure Repos.
    • Mappsökvägar: Mappen för ARM-malldefinitionerna i förhållande till URL:en för Git-klonen. Se till att inkludera det första snedstrecket i mappsökvägen.

  5. Välj Spara.

    Skärmbild som visar hur du lägger till en ny artefaktlagringsplats i ett labb.

Lagringsplatsen visas nu i listan Lagringsplatser för labbet.

Lägga till en artefaktlagringsplats med hjälp av en ARM-mall

ARM-mallar är JSON-filer som beskriver Azure-resurser som ska skapas. Mer information om ARM-mallar finns i Förstå strukturen och syntaxen för ARM-mallar.

Följande ARM-mall lägger till en artefaktlagringsplats i ett labb. Mallen skapar labbet om det inte redan finns.

Granska ARM-mallen

Exempelmallen samlar in följande information i parametrar. Vissa parametrar har standardvärden, men distributionskommandot måste ange labbnamnet, URI:n för artefaktlagringsplatsen, lagringsplatstypen och lagringsplatsens personliga åtkomsttoken.

  • Labbnamn.
  • Visningsnamn för artefaktlagringsplatsen i DevTest Labs. Standardvärdet är Team Repository.
  • URI för artefaktlagringsplatsen, som du kopierade tidigare.
  • Lagringsplatsgren som innehåller artefakterna. Standardvärdet är main.
  • Namnet på mappen som innehåller artefakterna. Standardvärdet är: /Artifacts.
  • Lagringsplatstyp. De tillåtna värdena är VsoGit, för Azure Repos eller GitHub.
  • Personlig åtkomsttoken för lagringsplatsen, som du kopierade tidigare.
{

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

Distribuera mallen

Det finns flera sätt att distribuera ARM-mallar för att skapa eller uppdatera Azure-resurser. Mer information och instruktioner finns i följande artiklar:

I det här exemplet distribuerar du mallen med hjälp av Azure PowerShell.

Anteckning

De cmdletar som distribuerar mallen är kontextspecifika, så de använder den aktuella klientorganisationen och prenumerationen. Om du behöver ändra kontexten använder du Set-AzContext innan du distribuerar mallen

  1. Skapa en resursgrupp med hjälp av New-AzResourceGroup. Om den resursgrupp som du vill använda redan finns hoppar du över det här steget.

    New-AzResourceGroup -Name MyLabResourceGroup1 -Location westus

  2. Skapa en distribution till resursgruppen med hjälp av New-AzResourceGroupDeployment. Du kan göra flera resursdistributioner till samma resursgrupp. Om du distribuerar flera gånger till samma resursgrupp kontrollerar du att varje distributionsnamn är unikt.

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

När New-AzResourceGroupDeployment körningen är klar visar utdata viktig information som etableringstillståndet, som ska vara succeeded, och eventuella utdata för mallen.

Lägga till en artefaktlagringsplats med hjälp av Azure PowerShell

Följande PowerShell-exempelskript ,New-DevTestLabArtifactRepository.ps1, lägger till en artefaktlagringsplats i ett labb. Det fullständiga skriptet innehåller några utförliga meddelanden och kommentarer.


<#

.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

Parametrar

PowerShell-skriptet har följande parametrar:

Parameter Beskrivning
LabName Namnet på labbet.
ArtifactRepositoryName Namn på den nya artefaktlagringsplatsen. Skriptet skapar ett slumpmässigt namn för lagringsplatsen om det inte anges.
ArtifactRepositoryDisplayName Visningsnamn som visas i labbets lista över artefaktlagringsplatser.
RepositoryUri URI för artefaktlagringsplatsen, som du kopierade tidigare.
RepositoryBranch Lagringsplatsgren som innehåller artefakterna. Standardvärdet är main.
FolderPath Mapp som innehåller artefakterna. Standardvärdet är: /Artifacts.
PersonalAccessToken Säkerhetstoken för åtkomst till lagringsplatsen, som du kopierade tidigare.
SourceType Om artefaktlagringsplatsen är en VSOGit-lagringsplats (Azure Repos) eller GitHub-lagringsplats.

Lagringsplatsen behöver ett internt namn för identifiering, vilket skiljer sig från visningsnamnet i Azure Portal. Du ser inte det interna namnet när du använder Azure Portal, men du ser det när du använder Azure REST API:er eller Azure PowerShell. Skriptet skapar ett slumpmässigt namn om distributionskommandot inte anger något.

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

PowerShell-kommandon

Skriptet använder följande PowerShell-kommandon:

Kommando Kommentarer
Get-AzResource Hämtar information om labbet, till exempel dess plats. Du skapar artefaktlagringsplatsens källa på samma plats och under samma resursgrupp som labbet.
New-AzResource Lägger till Azure-resursen. Det finns inget specifikt kommando för att lägga till artefaktlagringsplatser. Den här cmdleten ResourceIdResourceName behöver antingen eller och-paret ResourceType för att känna till vilken typ av resurs som ska skapas. Det aktuella skriptet ResourceName använder paret och ResourceType .

Ett bra sätt att identifiera resursnamn och resurstypsinformation är att använda webbplatsen för Azure REST API Browser . DevTest Labs Artifact Sources visar REST-API:er för att skapa och hantera DevTest Labs-artefaktkällor. Det aktuella skriptet använder följande resurs-ID:

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

Resurstypen är allt som visas efter providers i URI:n, förutom objekt inom klammerparenteser. Resursnamnet är allt inom klammerparenteserna. Om du använder mer än ett objekt för resursnamnet separerar du varje objekt med ett snedstreck:

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

Kör PowerShell-skriptet

Kör PowerShell-skriptet och ersätt dina egna värden med exempelvärdena i LabName, LabResourceGroupName, ArtifactRepositoryName, RepositoryUri, PersonalAccessTokenoch 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"

Nästa steg