Snabbstart: Skapa och publicera en azure-definition för hanterat program
Den här snabbstarten ger en introduktion till att arbeta med Azure Managed Applications. Du skapar och publicerar ett hanterat program som lagras i tjänstkatalogen och är avsett för medlemmar i din organisation.
Om du vill publicera ett hanterat program i tjänstkatalogen gör du följande:
- Skapa en Azure Resource Manager-mall (ARM-mall) som definierar de resurser som ska distribueras med det hanterade programmet.
- Definiera användargränssnittselementen för portalen när du distribuerar det hanterade programmet.
- Skapa ett .zip paket som innehåller de mallfiler som krävs. Den .zip paketfilen har en gräns på 120 MB för en tjänstkatalogs definition av hanterade program.
- Bestämma vilken användare, vilken grupp eller vilket program som behöver åtkomst till resursgruppen i användarens prenumeration.
- Skapa definitionen för det hanterade programmet som pekar på .zip-paketet och begär åtkomst för identiteten.
Valfritt: Om du vill distribuera definitionen för det hanterade programmet med en ARM-mall i ditt eget lagringskonto kan du läsa Ta med din egen lagring.
Anteckning
Bicep-filer kan inte användas i ett hanterat program. Du måste konvertera en Bicep-fil till ARM-mallens JSON med Bicep-kompileringskommandot .
Förutsättningar
För att slutföra den här snabbstarten behöver du följande:
- Ett Azure-konto med en aktiv prenumeration. Om du inte har något konto kan du skapa ett kostnadsfritt konto innan du börjar.
- Visual Studio Code med det senaste Azure Resource Manager Tools-tillägget.
- Installera den senaste versionen av Azure PowerShell eller Azure CLI.
Skapa ARM-mallen
Alla definitioner för hanterade program innehåller en fil med namnet mainTemplate.json. Mallen definierar de Azure-resurser som ska distribueras och skiljer sig inte från en vanlig ARM-mall.
Öppna Visual Studio Code, skapa en fil med det skiftlägeskänsliga namnet mainTemplate.json och spara den.
Lägg till följande JSON och spara filen. Den definierar parametrarna för att skapa ett lagringskonto och anger egenskaperna för lagringskontot.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"storageAccountNamePrefix": {
"type": "string",
"maxLength": 11,
"metadata": {
"description": "Storage prefix must be maximum of 11 characters with only lowercase letters or numbers."
}
},
"storageAccountType": {
"type": "string"
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]"
}
},
"variables": {
"storageAccountName": "[concat(parameters('storageAccountNamePrefix'), uniqueString(resourceGroup().id))]"
},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"apiVersion": "2021-09-01",
"name": "[variables('storageAccountName')]",
"location": "[parameters('location')]",
"sku": {
"name": "[parameters('storageAccountType')]"
},
"kind": "StorageV2",
"properties": {}
}
],
"outputs": {
"storageEndpoint": {
"type": "string",
"value": "[reference(resourceId('Microsoft.Storage/storageAccounts/', variables('storageAccountName')), '2021-09-01').primaryEndpoints.blob]"
}
}
}
Definiera din skapandeupplevelse
Som utgivare definierar du portalupplevelsen för att skapa det hanterade programmet. Filen createUiDefinition.json genererar portalgränssnittet. Du definierar hur användare anger indata för varje parameter med hjälp av kontrollelement , inklusive listrutor, textrutor och lösenordsrutor.
Öppna Visual Studio Code, skapa en fil med det skiftlägeskänsliga namnet createUiDefinition.json och spara den.
Lägg till följande JSON i filen och spara den.
{
"$schema": "https://schema.management.azure.com/schemas/0.1.2-preview/CreateUIDefinition.MultiVm.json#",
"handler": "Microsoft.Azure.CreateUIDef",
"version": "0.1.2-preview",
"parameters": {
"basics": [
{}
],
"steps": [
{
"name": "storageConfig",
"label": "Storage settings",
"subLabel": {
"preValidation": "Configure the infrastructure settings",
"postValidation": "Done"
},
"bladeTitle": "Storage settings",
"elements": [
{
"name": "storageAccounts",
"type": "Microsoft.Storage.MultiStorageAccountCombo",
"label": {
"prefix": "Storage account name prefix",
"type": "Storage account type"
},
"defaultValue": {
"type": "Standard_LRS"
},
"constraints": {
"allowedTypes": [
"Premium_LRS",
"Standard_LRS",
"Standard_GRS"
]
}
}
]
}
],
"outputs": {
"storageAccountNamePrefix": "[steps('storageConfig').storageAccounts.prefix]",
"storageAccountType": "[steps('storageConfig').storageAccounts.type]",
"location": "[location()]"
}
}
}
Mer information finns i Kom igång med CreateUiDefinition.
Paketera filerna
Lägg till de två filerna i en fil med namnet app.zip. De två filerna måste vara på rotnivån för .zip-filen . Om du placerar filerna i en mapp får du ett felmeddelande om att de nödvändiga filerna inte finns när du skapar definitionen för det hanterade programmet.
Ladda upp paketet till en tillgänglig plats som det kan användas från. Lagringskontots namn måste vara globalt unikt i Azure och längden måste vara mellan 3 och 24 tecken med endast gemener och siffror. I parametern Name
ersätter du platshållaren demostorageaccount
med ditt unika lagringskontonamn.
New-AzResourceGroup -Name storageGroup -Location eastus
$storageAccount = New-AzStorageAccount `
-ResourceGroupName storageGroup `
-Name "demostorageaccount" `
-Location eastus `
-SkuName Standard_LRS `
-Kind StorageV2
$ctx = $storageAccount.Context
New-AzStorageContainer -Name appcontainer -Context $ctx -Permission blob
Set-AzStorageBlobContent `
-File "D:\myapplications\app.zip" `
-Container appcontainer `
-Blob "app.zip" `
-Context $ctx
Skapa definitionen för det hanterade programmet
I det här avsnittet får du identitetsinformation från Azure Active Directory, skapar en resursgrupp och skapar definitionen för det hanterade programmet.
Skapa en Azure Active Directory-användargrupp eller ett Azure Active Directory-program
Nästa steg är att välja en användargrupp, användare eller ett program för att hantera kundens resurser. Den här identiteten har behörigheter för den hanterade resursgruppen enligt den roll som har tilldelats. Rollen kan vara valfri inbyggd Azure-roll som ägare eller deltagare. Information om hur du skapar en ny Active Directory-användargrupp finns i Skapa en grupp och lägga till medlemmar i Azure Active Directory.
I det här exemplet används en användargrupp, så du behöver objekt-ID:t för användargruppen som ska användas för att hantera resurserna. Ersätt platshållaren mygroup
med gruppens namn.
$groupID=(Get-AzADGroup -DisplayName mygroup).Id
Hämta rolldefinitions-ID:t
Därefter behöver du rolldefinitions-ID:t för den inbyggda Azure-rollen som du vill bevilja åtkomst till användaren, användargruppen eller programmet. Normalt använder du rollen Ägare, Deltagare eller Läsare. Följande kommando visar hur du hämtar rolldefinitions-ID:t för ägarrollen:
$roleid=(Get-AzRoleDefinition -Name Owner).Id
Skapa definitionen för det hanterade programmet
Om du inte redan har en resursgrupp för lagring av definitionen för det hanterade programmet skapar du en ny resursgrupp.
Valfritt: Om du vill distribuera definitionen för det hanterade programmet med en ARM-mall i ditt eget lagringskonto kan du läsa Ta med din egen lagring.
New-AzResourceGroup -Name appDefinitionGroup -Location westcentralus
Skapa definitionsresursen för det hanterade programmet. I parametern Name
ersätter du platshållaren demostorageaccount
med ditt unika lagringskontonamn.
Kommandot blob
som körs från Azure PowerShell eller Azure CLI skapar en variabel som används för att hämta URL:en för paketet .zip filen. Variabeln används i kommandot som skapar definitionen för det hanterade programmet.
$blob = Get-AzStorageBlob -Container appcontainer -Blob app.zip -Context $ctx
New-AzManagedApplicationDefinition `
-Name "ManagedStorage" `
-Location "westcentralus" `
-ResourceGroupName appDefinitionGroup `
-LockLevel ReadOnly `
-DisplayName "Managed Storage Account" `
-Description "Managed Azure Storage Account" `
-Authorization "${groupID}:$roleid" `
-PackageFileUri $blob.ICloudBlob.StorageUri.PrimaryUri.AbsoluteUri
När kommandot har slutförts har du en definition för det hanterade programmet i resursgruppen.
Några av de parametrar som användes i det föregående exemplet är:
resursgrupp: Namnet på resursgruppen där definitionen för det hanterade programmet skapas.
låsnivå: Den typ av lås som placeras på den hanterade resursgruppen. Det förhindrar kunden från att utföra oönskade åtgärder på den här resursgruppen.
ReadOnly
Är för närvarande den enda låsnivå som stöds. NärReadOnly
har angetts kan kunden bara läsa de resurser som finns i den hanterade resursgruppen. Utgivaridentiteter som beviljas åtkomst till den hanterade resursgruppen är undantagna från låset.auktorisering: Beskriver huvudkontots ID och rolldefinitions-ID som används för att ge behörigheter till den hanterade resursgruppen.
- Azure PowerShell:
"${groupid}:$roleid"
eller så kan du använda klammerparenteser för varje variabel"${groupid}:${roleid}"
. Använd ett kommatecken för att avgränsa flera värden:"${groupid1}:$roleid1", "${groupid2}:$roleid2"
. - Azure CLI:
"$groupid:$roleid"
eller så kan du använda klammerparenteser som visas i PowerShell. Använd ett blanksteg för att avgränsa flera värden:"$groupid1:$roleid1" "$groupid2:$roleid2"
.
- Azure PowerShell:
URI för paketfil: Platsen för en .zip paketfil som innehåller de filer som krävs.
Ta med din egen lagring för definitionen av det hanterade programmet
Det här avsnittet är valfritt. Du kan lagra definitionen av det hanterade programmet i ditt eget lagringskonto så att dess plats och åtkomst kan hanteras av dig för dina regelbehov. Den .zip paketfilen har en gräns på 120 MB för en tjänstkatalogs definition av hanterade program.
Anteckning
Bring Your Own Storage stöds bara med ARM-mallar eller REST API-distributioner av definitionen för det hanterade programmet.
Skapa ditt lagringskonto
Du måste skapa ett lagringskonto som innehåller definitionen för det hanterade programmet för användning med en tjänstkatalog. Lagringskontots namn måste vara globalt unikt i Azure och längden måste vara mellan 3 och 24 tecken med endast gemener och siffror.
I det här exemplet skapas en ny resursgrupp med namnet byosStorageRG
. I parametern Name
ersätter du platshållaren definitionstorage
med ditt unika lagringskontonamn.
New-AzResourceGroup -Name byosStorageRG -Location eastus
New-AzStorageAccount `
-ResourceGroupName byosStorageRG `
-Name "definitionstorage" `
-Location eastus `
-SkuName Standard_LRS `
-Kind StorageV2
Använd följande kommando för att lagra lagringskontots resurs-ID i en variabel med namnet storageId
. Du använder den här variabeln när du distribuerar definitionen för det hanterade programmet.
$storageId = (Get-AzStorageAccount -ResourceGroupName byosStorageRG -Name definitionstorage).Id
Ange rolltilldelningen för ditt lagringskonto
Innan definitionen för det hanterade programmet kan distribueras till ditt lagringskonto tilldelar du rollen Deltagare till användaren av installationsresursprovidern i lagringskontots omfång. Med den här tilldelningen kan identiteten skriva definitionsfiler till lagringskontots container.
I PowerShell kan du använda variabler för rolltilldelningen. I det här exemplet används som $storageId
du skapade i ett tidigare steg och variabeln $arpId
skapas.
$arpId = (Get-AzADServicePrincipal -SearchString "Appliance Resource Provider").Id
New-AzRoleAssignment -ObjectId $arpId `
-RoleDefinitionName Contributor `
-Scope $storageId
Resursprovidern för installationen är ett huvudnamn för tjänsten i din Azure Active Directory-klientorganisation. Från Azure Portal kan du se om den är registrerad genom att gå till Azure Active Directory Enterprise-program> och ändra sökfiltret till Microsoft Applications. Sök efter resursprovidern för installationen. Om den inte hittas registrerar duMicrosoft.Solutions
resursprovidern.
Distribuera definitionen för det hanterade programmet med en ARM-mall
Använd följande ARM-mall för att distribuera ditt paketerade hanterade program som en ny definition för hanterade program i tjänstkatalogen. Definitionsfilerna lagras och underhålls i ditt lagringskonto.
Öppna Visual Studio Code, skapa en fil med namnet azuredeploy.json och spara den.
Lägg till följande JSON och spara filen.
{
"$schema": "http://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]"
},
"applicationName": {
"type": "string",
"metadata": {
"description": "Managed Application name."
}
},
"definitionStorageResourceID": {
"type": "string",
"metadata": {
"description": "Storage account's resource ID where you're storing your managed application definition."
}
},
"packageFileUri": {
"type": "string",
"metadata": {
"description": "The URI where the .zip package file is located."
}
}
},
"variables": {
"lockLevel": "None",
"description": "Sample Managed application definition",
"displayName": "Sample Managed application definition",
"managedApplicationDefinitionName": "[parameters('applicationName')]",
"packageFileUri": "[parameters('packageFileUri')]",
"defLocation": "[parameters('definitionStorageResourceID')]"
},
"resources": [
{
"type": "Microsoft.Solutions/applicationDefinitions",
"apiVersion": "2021-07-01",
"name": "[variables('managedApplicationDefinitionName')]",
"location": "[parameters('location')]",
"properties": {
"lockLevel": "[variables('lockLevel')]",
"description": "[variables('description')]",
"displayName": "[variables('displayName')]",
"packageFileUri": "[variables('packageFileUri')]",
"storageAccountId": "[variables('defLocation')]"
}
}
],
"outputs": {}
}
Mer information om ARM-mallens egenskaper finns i Microsoft.Solutions/applicationDefinitions. Hanterade program använder endast ARM-mallens JSON.
Distribuera definitionen
Skapa en resursgrupp med namnet byosDefinitionRG och distribuera definitionen för det hanterade programmet till ditt lagringskonto.
New-AzResourceGroup -Name byosDefinitionRG -Location eastus
$storageId
New-AzResourceGroupDeployment `
-ResourceGroupName byosDefinitionRG `
-TemplateFile .\azuredeploy.json
Du uppmanas att ange tre parametrar för att distribuera definitionen.
Parameter | Värde |
---|---|
applicationName |
Välj ett namn för definitionen av det hanterade programmet. I det här exemplet använder du sampleManagedAppDefintion. |
definitionStorageResourceID |
Ange ditt lagringskontos resurs-ID. Du skapade variabeln storageId med det här värdet i ett tidigare steg. Omslut inte resurs-ID:t med citattecken. |
packageFileUri |
Ange URI:n i .zip-paketfilen . Använd URI:n för .zip-paketfilen som du skapade i ett tidigare steg. Formatet är https://yourStorageAccountName.blob.core.windows.net/appcontainer/app.zip . |
Verifiera lagring av definitionsfiler
Under distributionen använder mallens egenskap ditt lagringskontos resurs-ID och skapar en ny container med det skiftlägeskänsliga storageAccountId
namnet applicationdefinitions
. Filerna från det.zip paket som du angav under distributionen lagras i den nya containern.
Du kan använda följande kommandon för att kontrollera att definitionsfilerna för hanterade program sparas i lagringskontots container. I parametern Name
ersätter du platshållaren definitionstorage
med ditt unika lagringskontonamn.
Get-AzStorageAccount -ResourceGroupName byosStorageRG -Name definitionstorage |
Get-AzStorageContainer -Name applicationdefinitions |
Get-AzStorageBlob | Select-Object -Property *
Anteckning
För ökad säkerhet kan du skapa en definition för hanterade program och lagra den i en Azure Storage-kontoblob där kryptering är aktiverat. Definitionsinnehållet krypteras via lagringskontots krypteringsalternativ. Endast användare med behörighet till filen kan se definitionen i tjänstkatalogen.
Kontrollera att användare kan se din definition
Du har åtkomst till definitionen för hanterade program, men du vill kontrollera att andra användare i din organisation kan komma åt den. Ge dem minst rollen Läsare på definitionen. De kan ha ärvt den här åtkomstnivån från prenumerationen eller resursgruppen. Information om vem som har åtkomst till definitionen och lägga till användare eller grupper finns i Tilldela Azure-roller med hjälp av Azure Portal.
Nästa steg
Du har publicerat definitionen av det hanterade programmet. Nu ska du lära dig hur du distribuerar en instans av den definitionen.