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:

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är ReadOnly 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".
  • 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.