Lägga till ett artefaktcentrallager till ett labb

Artikel
06/03/2024

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 som standard tillgängliga i DevTest Labs. Information om hur du lägger till artefakter till 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-portalen, 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.

Kommentar

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Information om hur du kommer igång finns i Installera Azure PowerShell. 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 måste du känna till Git HTTPS-klonings-URL:en och den personliga åtkomsttoken för GitHub- eller Azure Repos-lagringsplatsen som har artefaktfilerna.

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

På startsidan för GitHub-lagringsplatsen som har dina artefakter väljer du Kod och kopierar HTTPS-URL:en under Klona.
Välj din profilbild i det övre högra hörnet av GitHub och välj sedan Inställningar.
På profilsidan går du till den vänstra menyn och väljer Developer Inställningar (Utvecklare Inställningar) och sedan Personliga åtkomsttoken.
Välj Generera ny token.
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.
Spara den genererade token.

Hämta klonings-URL:en och den personliga åtkomsttoken för Azure Repos

På huvudsidan för lagringsplatsen som innehåller dina artefakter väljer du Klona. På sidan Klona lagringsplats kopierar du klonings-URL:en.
I det övre högra hörnet på sidan Azure DevOps väljer du Användarinställningar>Personliga åtkomsttoken.
På sidan Personliga åtkomsttoken väljer du Ny token.
Fyll i informationen för token, välj Läs för omfången och välj sedan Skapa.
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-portalen

På labbsidan Översikt väljer du Konfiguration och principer i det vänstra navigeringsfältet.
På sidan Konfiguration och principer väljer du Lagringsplatser under Externa resurser i det vänstra navigeringsfältet.

På sidan Lagringsplatser visas den offentliga artefaktlagringsplatsen automatiskt och ansluter till den offentliga GitHub-lagringsplatsen DevTest Labs. Om den här lagringsplatsen inte är aktiverad för ditt labb kan du aktivera den genom att markera kryssrutan bredvid Offentlig artefaktrepo och sedan välja Aktivera på den översta menyraden.
Om du vill lägga till artefaktlagringsplatsen i labbet väljer du Lägg till i den översta menyraden.
I fönstret Lagringsplats anger du följande information:
- Namn: Ett lagringsplatsnamn som ska användas i labbet.
- Url för Git-klon: Git HTTPS-klonings-URL:en 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 Git-klonens URL. Se till att inkludera det första snedstrecket för vidarebefordran i mappsökvägen.
Välj Spara.

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, artefaktlagringsplatsens URI, lagringsplatstyp 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.

Kommentar

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

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
```
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 har körts 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 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

Parametrar

PowerShell-skriptet tar följande parametrar:

Parameter	Description
`LabName`	Namnet på labbet.
`ArtifactRepositoryName`	Namn på den nya artefaktlagringsplatsen. Skriptet skapar ett slumpmässigt namn för lagringsplatsen om det inte har angetts.
`ArtifactRepositoryDisplayName`	Visningsnamn som visas i labbets artefaktlagringsplatslista.
`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-portalen. Du ser inte det interna namnet när du använder Azure-portalen, 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:

Command	Kommentar
Get-AzResource	Hämtar information om labbet, till exempel dess plats. Du skapar källan för artefaktlagringsplatsen 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 `ResourceId` `ResourceName` 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 anges 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"

Dela via