Automatyzowanie wdrażania zasobów dla aplikacji funkcji w usłudze Azure Functions

  • Artykuł

Możesz użyć pliku Bicep lub szablonu usługi Azure Resource Manager, aby zautomatyzować proces wdrażania aplikacji funkcji w nowych lub istniejących zasobach platformy Azure. Taka automatyzacja zapewnia doskonały sposób integrowania wdrożeń zasobów z kodem źródłowym w metodyce DevOps, przywracania aplikacji funkcji i powiązanych zasobów z kopii zapasowej lub wielokrotnego wdrażania topologii aplikacji.

W tym artykule pokazano, jak zautomatyzować tworzenie zasobów i wdrażanie dla usługi Azure Functions. W zależności od wyzwalaczy i powiązań używanych przez funkcje może być konieczne wdrożenie innych zasobów, które wykraczają poza zakres tego artykułu.

Określony kod szablonu zależy od sposobu hostowania aplikacji funkcji, niezależnie od tego, czy wdrażasz kod, czy aplikację funkcji konteneryzowanych oraz system operacyjny używany przez aplikację. Ten artykuł obsługuje następujące opcje hostingu:

Opcja hostingu Typ wdrożenia Aby dowiedzieć się więcej, zobacz...
Plan użycia usługi Azure Functions Tylko kod Plan zużycia
Plan elastycznej wersji Premium usługi Azure Functions Kod | Kontenera Plan Premium
Plan usługi Azure Functions Dedicated (App Service) Kod | Kontenera Dedykowany plan
Azure Container Apps Tylko kontener Hostowanie usługi Azure Functions w usłudze Container Apps
Azure Arc Kod | Kontenera App Service, Functions i Logic Apps w usłudze Azure Arc (wersja zapoznawcza)

Wymagane zasoby

Wdrożenie hostowane w usłudze Azure Functions zwykle składa się z następujących zasobów:

Zasób Wymaganie Dokumentacja składni i właściwości
Konto magazynu Wymagania Microsoft.Storage/storageAccounts
Składnik Szczegółowe informacje aplikacji Zalecane Microsoft. Szczegółowe informacje/składniki
Plan hostingu Wymagane1 Microsoft.Web/serverfarms
Aplikacja funkcji Wymagania Microsoft.Web/sites

Wdrożenie usługi Azure Functions dla planu Zużycie zwykle składa się z następujących zasobów:

Zasób Wymaganie Dokumentacja składni i właściwości
Konto magazynu Wymagania Microsoft.Storage/storageAccounts
Składnik Szczegółowe informacje aplikacji Zalecane Microsoft. Szczegółowe informacje/składniki
Aplikacja funkcji Wymagania Microsoft.Web/sites

Wdrożenie hostowane w usłudze Azure Container Apps zwykle składa się z następujących zasobów:

Zasób Wymaganie Dokumentacja składni i właściwości
Konto magazynu Wymagania Microsoft.Storage/storageAccounts
Składnik Szczegółowe informacje aplikacji Zalecane Microsoft. Szczegółowe informacje/składniki
Środowisko zarządzane Wymagania Microsoft.App/managedEnvironments
Aplikacja funkcji Wymagania Microsoft.Web/sites

Wdrożenie hostowane w usłudze Azure Arc zwykle składa się z następujących zasobów:

Zasób Wymaganie Dokumentacja składni i właściwości
Konto magazynu Wymagania Microsoft.Storage/storageAccounts
Składnik Szczegółowe informacje aplikacji Zalecane Microsoft. Szczegółowe informacje/składniki
Środowisko Kubernetes usługi App Service Wymagania Microsoft.ExtendedLocation/customLocations
Aplikacja funkcji Wymagania Microsoft.Web/sites

1Jawny plan hostingu nie jest wymagany, jeśli zdecydujesz się hostować aplikację funkcji w planie Zużycie.

Podczas wdrażania wielu zasobów w jednym pliku Bicep lub szablonie usługi ARM ważna jest kolejność tworzenia zasobów. To wymaganie jest wynikiem zależności między zasobami. W przypadku takich zależności należy użyć dependsOn elementu do zdefiniowania zależności w zasobie zależnym. Aby uzyskać więcej informacji, zobacz Define the order for deploying resources in ARM templates or Resource dependencies in Bicep (Definiowanie kolejności wdrażania zasobów w szablonach usługi ARM lub zależności zasobów w aplikacji Bicep).

W tym artykule założono, że masz podstawową wiedzę na temat tworzenia plików Bicep lub tworzenia szablonów usługi Azure Resource Manager, a przykłady są wyświetlane jako poszczególne sekcje dla określonych zasobów. Aby zapoznać się z szerokim zestawem kompletnych przykładów plików Bicep i szablonów usługi ARM, zobacz przykłady wdrażania aplikacji funkcji.

Wymagania wstępne

W tym artykule założono, że utworzono już środowisko zarządzane w usłudze Azure Container Apps. Potrzebujesz zarówno nazwy, jak i identyfikatora środowiska zarządzanego, aby utworzyć aplikację funkcji hostowaną w usłudze Container Apps.

W tym artykule założono, że utworzono już niestandardową lokalizację z obsługą usługi App Service w klastrze Kubernetes z obsługą usługi Azure Arc. Aby utworzyć aplikację funkcji hostowaną w niestandardowej lokalizacji w lokalizacji niestandardowej usługi Azure Arc, potrzebujesz zarówno identyfikatora lokalizacji niestandardowej, jak i identyfikatora środowiska Kubernetes.

Tworzenie konta magazynu

Wszystkie aplikacje funkcji wymagają konta usługi Azure Storage. Potrzebujesz konta ogólnego przeznaczenia, które obsługuje obiekty blob, tabele, kolejki i pliki. Aby uzyskać więcej informacji, zobacz Wymagania dotyczące konta magazynu usługi Azure Functions.

Ważne

Konto magazynu służy do przechowywania ważnych danych aplikacji, czasami w tym samego kodu aplikacji. Należy ograniczyć dostęp z innych aplikacji i użytkowników do konta magazynu.

W tej przykładowej sekcji utworzysz konto magazynu ogólnego przeznaczenia w warstwie Standardowa w wersji 2:

"resources": [
  {
    "type": "Microsoft.Storage/storageAccounts",
    "apiVersion": "2022-05-01",
    "name": "[parameters('storageAccountName')]",
    "location": "[parameters('location')]",
    "kind": "StorageV2",
    "sku": {
      "name": "[parameters('storageAccountType')]"
    },
    "properties": {
      "supportsHttpsTrafficOnly": true,
      "defaultToOAuthAuthentication": true
    }
  }
]

Aby uzyskać więcej informacji na temat kontekstu, zobacz pełny plik azuredeploy.json w repozytorium szablonów.

Musisz ustawić parametry połączenia tego konta magazynu jako AzureWebJobsStorage ustawienie aplikacji, którego wymaga usługa Functions. Szablony w tym artykule tworzą tę wartość parametry połączenia na podstawie utworzonego konta magazynu, co jest najlepszym rozwiązaniem. Aby uzyskać więcej informacji, zobacz Konfiguracja aplikacji.

Włączanie dzienników magazynu

Ponieważ konto magazynu jest używane dla ważnych danych aplikacji funkcji, należy monitorować konto pod kątem modyfikacji tej zawartości. Aby monitorować konto magazynu, należy skonfigurować dzienniki zasobów usługi Azure Monitor dla usługi Azure Storage. W tej przykładowej sekcji obszar roboczy usługi Log Analytics o nazwie myLogAnalytics jest używany jako miejsce docelowe tych dzienników.

"resources": [
  {
    "type": "Microsoft.Insights/diagnosticSettings",
    "apiVersion": "2021-05-01-preview",
    "scope": "[format('Microsoft.Storage/storageAccounts/{0}/blobServices/default', parameters('storageAccountName'))]",
    "name": "[parameters('storageDataPlaneLogsName')]",
    "properties": {
        "workspaceId": "[resourceId('Microsoft.OperationalInsights/workspaces', parameters('myLogAnalytics'))]",
        "logs": [
          {
            "category": "StorageWrite",
            "enabled": true
          }
        ],
        "metrics": [
          {
            "category": "Transaction",
            "enabled": true
          }
        ]
    }
  }
]

Tego samego obszaru roboczego można użyć dla zasobu Application Szczegółowe informacje zdefiniowanego później. Aby uzyskać więcej informacji, w tym sposób pracy z tymi dziennikami, zobacz Monitorowanie usługi Azure Storage.

Tworzenie Szczegółowe informacje aplikacji

Szczegółowe informacje aplikacji zaleca się monitorowanie wykonań aplikacji funkcji. W tej przykładowej sekcji zasób Application Szczegółowe informacje jest definiowany z typem Microsoft.Insights/components i typem web:

{
  "type": "Microsoft.Insights/components",
  "apiVersion": "2020-02-02",
  "name": "[variables('applicationInsightsName')]",
  "location": "[parameters('appInsightsLocation')]",
  "tags": {
    "[format('hidden-link:{0}', resourceId('Microsoft.Web/sites', parameters('functionAppName')))]": "Resource"
  },
  "properties": {
    "Application_Type": "web"
  },
  "kind": "web"
},

Aby uzyskać więcej informacji na temat kontekstu, zobacz pełny plik azuredeploy.json w repozytorium szablonów.

Połączenie musi zostać dostarczone do aplikacji funkcji przy użyciu APPLICATIONINSIGHTS_CONNECTION_STRING ustawienia aplikacji. Aby uzyskać więcej informacji, zobacz Ustawienia aplikacji.

Przykłady w tym artykule uzyskują wartość parametry połączenia dla utworzonego wystąpienia. Starsze wersje mogą zamiast tego używać APPINSIGHTS_INSTRUMENTATIONKEY do ustawiania klucza instrumentacji, który nie jest już zalecany.

Tworzenie planu hostingu

Aplikacje hostowane w planie Premium usługi Azure Functions lub planie usługi App Service muszą mieć jawnie zdefiniowany plan hostingu.

Plan Premium oferuje takie samo skalowanie jak plan Zużycie, ale obejmuje dedykowane zasoby i dodatkowe możliwości. Aby dowiedzieć się więcej, zobacz Plan premium usługi Azure Functions.

Plan Premium to specjalny typ serverfarm zasobu. Można ją określić przy użyciu wartości EP1, EP2lub EP3 dla Name wartości właściwości we sku właściwości. Sposób definiowania planu hostingu usługi Functions zależy od tego, czy aplikacja funkcji działa w systemie Windows, czy w systemie Linux. Ta przykładowa sekcja tworzy EP1 plan:

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "sku": {
      "name": "EP1",
      "tier": "ElasticPremium",
      "family": "EP"
    },
    "kind": "elastic",
    "properties": {
      "maximumElasticWorkerCount": 20
    }
  }
]

Aby uzyskać więcej informacji na temat kontekstu, zobacz pełny plik azuredeploy.json w repozytorium szablonów.

Aby uzyskać więcej informacji na temat sku obiektu, zobacz SkuDefinition lub przejrzyj przykładowe szablony.

W ramach planu Dedykowane (App Service) aplikacja funkcji działa na dedykowanych maszynach wirtualnych w planach podstawowych, standardowych i Premium w planach usługi App Service, podobnie jak w przypadku aplikacji internetowych. Aby uzyskać więcej informacji, zobacz Dedykowany plan.

Aby zapoznać się z przykładowym plikiem Bicep/szablonem usługi Azure Resource Manager, zobacz Aplikacja funkcji w planie usługi aplikacja systemu Azure Service

W usłudze Functions plan dedykowany to zwykły plan usługi App Service, który jest definiowany serverfarm przez zasób. Musisz podać co najmniej name wartość. Aby uzyskać listę obsługiwanych nazw planów, zobacz --sku ustawienie w az appservice plan create sekcji dla bieżącej listy obsługiwanych wartości dla planu dedykowanego.

Sposób definiowania planu hostingu zależy od tego, czy aplikacja funkcji działa w systemie Windows, czy w systemie Linux:

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "sku": {
      "tier": "Standard",
      "name": "S1",
      "size": "S1",
      "family": "S",
      "capacity": 1
    }
  }
]

Aby uzyskać więcej informacji na temat kontekstu, zobacz pełny plik azuredeploy.json w repozytorium szablonów.

Tworzenie planu hostingu

Nie musisz jawnie definiować zasobu planu hostingu Zużycie. Po pominięcia tej definicji zasobu plan jest automatycznie tworzony lub wybierany dla poszczególnych regionów podczas tworzenia samego zasobu aplikacji funkcji.

Możesz jawnie zdefiniować plan Zużycie jako specjalny typ serverfarm zasobu, który określa się przy użyciu wartości Dynamic właściwości computeMode i sku . W tej przykładowej sekcji pokazano, jak jawnie zdefiniować plan zużycia. Sposób definiowania planu hostingu zależy od tego, czy aplikacja funkcji działa w systemie Windows, czy w systemie Linux.

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "sku": {
      "name": "Y1",
      "tier": "Dynamic",
      "size": "Y1",
      "family": "Y",
      "capacity": 0
    },
    "properties": {
      "computeMode": "Dynamic"
    }
  }
]

Aby uzyskać więcej informacji na temat kontekstu, zobacz pełny plik azuredeploy.json w repozytorium szablonów.

Środowisko Kubernetes

Usługę Azure Functions można wdrożyć na platformie Kubernetes z włączoną usługą Azure Arc jako projekt kodu lub konteneryzowaną aplikację funkcji.

Aby utworzyć zasoby aplikacji i planu, musisz już utworzyć środowisko Kubernetes usługi App Service dla klastra Kubernetes z obsługą usługi Azure Arc. W przykładach w tym artykule założono, że masz identyfikator zasobu lokalizacji niestandardowej (customLocationId) i środowiska Kubernetes usługi App Service (kubeEnvironmentId), w którym wdrażasz, które zostały ustawione w tym przykładzie:

"parameters": {
  "kubeEnvironmentId" : {
    "type": "string"
  },
  "customLocationId" : {
    "type": "string"
  }
}

Zarówno witryny, jak i plany muszą odwoływać się do lokalizacji niestandardowej extendedLocation za pomocą pola. Jak pokazano w tym obciętym przykładzie, extendedLocation znajduje się poza propertieselementem , jako element równorzędny i kindlocation:

{
  "type": "Microsoft.Web/serverfarms",
  ...
  {
    "extendedLocation": {
      "name": "[parameters('customLocationId')]"
    },
  }
}

Zasób planu powinien używać wartości Kubernetes (K1) dla SKU, kind pole powinno mieć linux,kuberneteswartość , a reserved właściwość powinna mieć truewartość , ponieważ jest to wdrożenie systemu Linux. Należy również ustawić extendedLocation identyfikator lokalizacji niestandardowej i kubeEnvironmentProfile.id identyfikator środowiska Kubernetes, odpowiednio, co może wyglądać następująco:

"resources": [
  {
    "type": "Microsoft.Web/serverfarms",
    "apiVersion": "2022-03-01",
    "name": "[parameters('hostingPlanName')]",
    "location": "[parameters('location')]",
    "kind": "linux,kubernetes",
    "sku": {
      "name": "K1",
      "tier": "Kubernetes"
    },
    "extendedLocation": {
      "name": "[parameters('customLocationId')]"
    },
    "properties": {
      "kubeEnvironmentProfile": {
        "id": "[parameters('kubeEnvironmentId')]"
      },
      "reserved": true
    }
  }
]

Tworzenie aplikacji funkcji

Zasób aplikacji funkcji jest definiowany przez zasób typu Microsoft.Web/sites i kind zawiera functionappwartość , co najmniej.

Sposób definiowania zasobu aplikacji funkcji zależy od tego, czy hostujesz w systemie Linux, czy w systemie Windows:

Aby uzyskać listę ustawień aplikacji wymaganych podczas uruchamiania w systemie Windows, zobacz Konfiguracja aplikacji. Aby zapoznać się z przykładowym plikiem Bicep/szablonem usługi Azure Resource Manager, zobacz aplikację funkcji hostowaną w systemie Windows w szablonie planu zużycie.

Aby uzyskać listę ustawień aplikacji wymaganych podczas uruchamiania w systemie Windows, zobacz Konfiguracja aplikacji.

Uwaga

Jeśli zdecydujesz się opcjonalnie zdefiniować plan Zużycie, musisz ustawić serverFarmId właściwość w aplikacji, aby wskazać identyfikator zasobu planu. Upewnij się, że aplikacja funkcji ma dependsOn ustawienie, które również odwołuje się do planu. Jeśli nie zdefiniowano jawnie planu, zostanie on utworzony dla Ciebie.

serverFarmId Ustaw właściwość w aplikacji, aby wskazywać identyfikator zasobu planu. Upewnij się, że aplikacja funkcji ma dependsOn ustawienie, które również odwołuje się do planu.

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "location": "[parameters('location')]",
    "kind": "functionapp",
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "siteConfig": {
        "appSettings": [
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "WEBSITE_CONTENTAZUREFILECONNECTIONSTRING",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "WEBSITE_CONTENTSHARE",
            "value": "[toLower(parameters('functionAppName'))]"
          },
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "FUNCTIONS_WORKER_RUNTIME",
            "value": "node"
          },
          {
            "name": "WEBSITE_NODE_DEFAULT_VERSION",
            "value": "~14"
          }
        ]
      }
    }
  }
]

Aby zapoznać się z kompletnym przykładem, zobacz ten szablon azuredeploy.json.

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "location": "[parameters('location')]",
    "kind": "functionapp",
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "siteConfig": {
        "alwaysOn": true,
        "appSettings": [
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', parameters('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "FUNCTIONS_WORKER_RUNTIME",
            "value": "node"
          },
          {
            "name": "WEBSITE_NODE_DEFAULT_VERSION",
            "value": "~14"
          }
        ]
      }
    }
  }
]

Aby zapoznać się z kompletnym przykładem, zobacz ten szablon azuredeploy.json.

Źródła wdrożenia

Plik Bicep lub szablon usługi ARM można opcjonalnie zdefiniować wdrożenie kodu funkcji, które może obejmować następujące metody:

Źródła wdrożenia

Plik Bicep lub szablon usługi ARM można opcjonalnie zdefiniować wdrożenie dla kodu funkcji przy użyciu pakietu wdrożeniowego zip.

Aby pomyślnie wdrożyć aplikację przy użyciu usługi Azure Resource Manager, ważne jest, aby zrozumieć, jak zasoby są wdrażane na platformie Azure. W większości przykładów konfiguracje najwyższego poziomu są stosowane przy użyciu polecenia siteConfig. Ważne jest, aby ustawić te konfiguracje na najwyższym poziomie, ponieważ przekazują informacje do środowiska uruchomieniowego i aparatu wdrażania usługi Functions. Informacje najwyższego poziomu są wymagane przed zastosowaniem zasobu podrzędnego sourcecontrols/web . Chociaż można skonfigurować te ustawienia w zasobie na poziomie config/appSettings podrzędnym, w niektórych przypadkach aplikacja funkcji musi zostać wdrożona przedconfig/appSettings zastosowaniem.

Pakiet wdrożeniowy zip

Wdrożenie zip to zalecany sposób wdrażania kodu aplikacji funkcji. Domyślnie funkcje korzystające z wdrożenia zip są uruchamiane w samym pakiecie wdrożeniowym. Aby uzyskać więcej informacji, w tym wymagania dotyczące pakietu wdrożeniowego, zobacz Wdrażanie zip dla usługi Azure Functions. W przypadku korzystania z automatyzacji wdrażania zasobów można odwołać się do pakietu wdrożeniowego .zip w szablonie Bicep lub ARM.

Aby użyć wdrożenia zip w szablonie, ustaw WEBSITE_RUN_FROM_PACKAGE ustawienie w aplikacji na 1 i dołącz definicję /zipDeploy zasobu.

W przypadku planu Zużycie w systemie Linux zamiast tego ustaw identyfikator URI pakietu wdrożeniowego bezpośrednio w WEBSITE_RUN_FROM_PACKAGE ustawieniu, jak pokazano w tym przykładowym szablonie.

W tym przykładzie dodano źródło wdrożenia zip do istniejącej aplikacji:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "functionAppName": {
      "type": "string",
      "metadata": {
        "description": "The name of the Azure Function app."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location into which the resources should be deployed."
      }
    },
    "packageUri": {
      "type": "string",
      "metadata": {
        "description": "The zip content url."
      }
    }
  },
  "resources": [
    {
      "name": "[concat(parameters('functionAppName'), '/ZipDeploy')]",
      "type": "Microsoft.Web/sites/extensions",
      "apiVersion": "2021-02-01",
      "location": "[parameters('location')]",
      "properties": {
        "packageUri": "[parameters('packageUri')]"
      }
    }
  ]
}

Podczas dołączania zasobów wdrożenia zip do szablonu należy pamiętać o następujących kwestiach:

  • Plany użycia w systemie Linux nie obsługują WEBSITE_RUN_FROM_PACKAGE = 1systemu . Zamiast tego należy ustawić identyfikator URI pakietu wdrożeniowego bezpośrednio w ustawieniu WEBSITE_RUN_FROM_PACKAGE . Aby uzyskać więcej informacji, zobacz WEBSITE_RUN_FROM_PACKAGE. Przykładowy szablon można znaleźć w temacie Aplikacja funkcji hostowana w systemie Linux w planie zużycie.

  • Musi packageUri to być lokalizacja, do którego można uzyskać dostęp za pomocą usługi Functions. Rozważ użycie usługi Azure Blob Storage z sygnaturą dostępu współdzielonego (SAS). Po wygaśnięciu sygnatury dostępu współdzielonego funkcje nie będą już mogły uzyskać dostępu do udziału dla wdrożeń. Podczas ponownego generowania sygnatury dostępu współdzielonego pamiętaj, aby zaktualizować WEBSITE_RUN_FROM_PACKAGE ustawienie przy użyciu nowej wartości identyfikatora URI.

  • Podczas ustawiania WEBSITE_RUN_FROM_PACKAGE identyfikatora URI należy ręcznie zsynchronizować wyzwalacze.

  • Pamiętaj, aby zawsze ustawiać wszystkie wymagane ustawienia aplikacji w appSettings kolekcji podczas dodawania lub aktualizowania ustawień. Istniejące ustawienia, które nie są jawnie ustawione, są usuwane przez aktualizację. Aby uzyskać więcej informacji, zobacz Konfiguracja aplikacji.

  • Usługa Functions nie obsługuje narzędzia Web Deploy (msdeploy) dla wdrożeń pakietów. Zamiast tego należy użyć wdrożenia zip w potokach wdrażania i automatyzacji. Aby uzyskać więcej informacji, zobacz Wdrażanie zip dla usługi Azure Functions.

Kompilacje zdalne

W procesie wdrażania przyjęto założenie, że używany plik .zip lub wdrożenie zip zawiera aplikację gotową do uruchomienia. Oznacza to, że domyślnie nie są uruchamiane żadne dostosowania.

Istnieją jednak scenariusze, które wymagają zdalnego ponownego kompilowania aplikacji, na przykład w przypadku konieczności ściągnięcia pakietów specyficznych dla systemu Linux w języku Python lub Node.js aplikacji utworzonych na komputerze z systemem Windows. W takim przypadku można skonfigurować funkcje tak, aby wykonywały zdalną kompilację kodu po wdrożeniu zip.

Sposób żądania kompilacji zdalnej zależy od systemu operacyjnego, do którego wdrażasz:

Po wdrożeniu aplikacji w systemie Windows są uruchamiane polecenia specyficzne dla języka (na przykład dotnet restore dla aplikacji języka C# lub npm install dla aplikacji Node.js).

Aby włączyć te same procesy kompilacji, które uzyskujesz z ciągłą integracją, dodaj SCM_DO_BUILD_DURING_DEPLOYMENT=true do ustawień aplikacji w kodzie wdrożenia i usuń je WEBSITE_RUN_FROM_PACKAGE całkowicie.

Kontenery systemu Linux

Jeśli wdrażasz konteneryzowaną aplikację funkcji w usłudze Azure Functions — wersja Premium lub Plan dedykowany, musisz:

Aby uzyskać więcej informacji, zobacz Konfiguracja aplikacji.

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "location": "[parameters('location')]",
    "kind": "functionapp",
    "dependsOn": [
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "siteConfig": {
        "appSettings": [
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}', parameters('storageAccountName'), listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "FUNCTIONS_WORKER_RUNTIME",
            "value": "node"
          },
          {
            "name": "WEBSITE_NODE_DEFAULT_VERSION",
            "value": "~14"
          },
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "DOCKER_REGISTRY_SERVER_URL",
            "value": "[parameters('dockerRegistryUrl')]"
          },
          {
            "name": "DOCKER_REGISTRY_SERVER_USERNAME",
            "value": "[parameters('dockerRegistryUsername')]"
          },
          {
            "name": "DOCKER_REGISTRY_SERVER_PASSWORD",
            "value": "[parameters('dockerRegistryPassword')]"
          },
          {
            "name": "WEBSITES_ENABLE_APP_SERVICE_STORAGE",
            "value": "false"
          }
        ],
        "linuxFxVersion": "DOCKER|myacr.azurecr.io/myimage:mytag"
      }
    }
  }
]

Podczas wdrażania konteneryzowanych funkcji w usłudze Azure Container Apps szablon musi:

  • kind Ustaw pole na wartość functionapp,linux,container,azurecontainerapps.
  • managedEnvironmentId Ustaw właściwość witryny na w pełni kwalifikowany identyfikator URI środowiska Container Apps.
  • Dodaj link do zasobu w zbiorze witryny dependsOn podczas tworzenia Microsoft.App/managedEnvironments zasobu w tym samym czasie co witryna.

Definicja konteneryzowanej aplikacji funkcji wdrożonej z prywatnego rejestru kontenerów w istniejącym środowisku usługi Container Apps może wyglądać następująco:

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "kind": "functionapp,linux,container,azurecontainerapps",
    "location": "[parameters('location')]",
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[parameters('hostingPlanName')]",
      "siteConfig": {
        "linuxFxVersion": "DOCKER|myacr.azurecr.io/myimage:mytag",
        "appSettings": [
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}', parameters('storageAccountName'), listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          }
        ],
      },
      "managedEnvironmentId": "[parameters('managedEnvironmentId')]"
    }
  }
]

Podczas wdrażania funkcji w usłudze Azure Arc wartość ustawiona dla kind pola zasobu aplikacji funkcji zależy od typu wdrożenia:

Typ wdrożenia kind wartość pola
Wdrożenie tylko do kodu functionapp,linux,kubernetes
Wdrażanie kontenera functionapp,linux,kubernetes,container

Należy również ustawić customLocationId wartość tak, jak w przypadku zasobu planu hostingu.

Definicja konteneryzowanej aplikacji funkcji korzystającej z obrazu szybkiego startu platformy .NET 6 może wyglądać następująco:

"resources": [
  {
    "type": "Microsoft.Web/sites",
    "apiVersion": "2022-03-01",
    "name": "[parameters('functionAppName')]",
    "kind": "kubernetes,functionapp,linux,container",
    "location": "[parameters('location')]",
    "extendedLocation": {
      "name": "[parameters('customLocationId')]"
    },
    "dependsOn": [
      "[resourceId('Microsoft.Insights/components', parameters('applicationInsightsName'))]",
      "[resourceId('Microsoft.Web/serverfarms', parameters('hostingPlanName'))]",
      "[resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName'))]"
    ],
    "properties": {
      "serverFarmId": "[parameters('hostingPlanName')]",
      "siteConfig": {
        "linuxFxVersion": "DOCKER|mcr.microsoft.com/azure-functions/4-dotnet-isolated6.0-appservice-quickstart",
        "appSettings": [
          {
            "name": "FUNCTIONS_EXTENSION_VERSION",
            "value": "~4"
          },
          {
            "name": "AzureWebJobsStorage",
            "value": "[format('DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}', parameters('storageAccountName'), listKeys(resourceId('Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-09-01').keys[0].value)]"
          },
          {
            "name": "APPLICATIONINSIGHTS_CONNECTION_STRING",
            "value": "[reference(resourceId('Microsoft.Insights/components', parameters('applicationInsightsName')), '2020-02-02').ConnectionString]"
          }
        ],
        "alwaysOn": true
      }
    }
  }
]

Konfiguracja aplikacji

Funkcje udostępnia następujące opcje konfigurowania aplikacji funkcji na platformie Azure:

Konfigurowanie Microsoft.Web/sites Właściwość
Ustawienia witryny siteConfig
Ustawienia aplikacji siteConfig.appSettings Kolekcji

Dla właściwości wymagane siteConfig są następujące ustawienia witryny:

Te ustawienia aplikacji są wymagane (lub zalecane) dla określonego systemu operacyjnego i opcji hostingu:

Te ustawienia aplikacji są wymagane w przypadku wdrożeń kontenerów:

Te ustawienia są wymagane tylko podczas wdrażania z prywatnego rejestru kontenerów:

Należy pamiętać o tych kwestiach podczas pracy z ustawieniami witryny i aplikacji przy użyciu plików Bicep lub szablonów usługi ARM:

  • Ważne zagadnienia dotyczące tego, kiedy należy ustawić WEBSITE_CONTENTSHARE w zautomatyzowanym wdrożeniu. Aby uzyskać szczegółowe wskazówki, zobacz dokumentację WEBSITE_CONTENTSHARE .
  • W przypadku wdrożeń kontenerów ustaw również wartość WEBSITES_ENABLE_APP_SERVICE_STORAGEfalsena , ponieważ zawartość aplikacji jest udostępniana w samym kontenerze.

  • Ustawienia aplikacji należy zawsze definiować jako siteConfig/appSettings kolekcję tworzonego Microsoft.Web/sites zasobu, tak jak w przykładach w tym artykule. Dzięki temu ustawienia, które aplikacja funkcji musi uruchomić, są dostępne podczas początkowego uruchamiania.

  • Podczas dodawania lub aktualizowania ustawień aplikacji przy użyciu szablonów upewnij się, że wszystkie istniejące ustawienia są uwzględniane w aktualizacji. Należy to zrobić, ponieważ podstawowe wywołania interfejsu API REST aktualizacji zastępują cały /config/appsettings zasób. Jeśli usuniesz istniejące ustawienia, aplikacja funkcji nie zostanie uruchomiona. Aby programowo zaktualizować poszczególne ustawienia aplikacji, możesz zamiast tego użyć interfejsu wiersza polecenia platformy Azure, programu Azure PowerShell lub witryny Azure Portal, aby wprowadzić te zmiany. Aby uzyskać więcej informacji, zobacz Praca z ustawieniami aplikacji.

Wdrożenia miejsc

Usługa Functions umożliwia wdrażanie różnych wersji kodu w unikatowych punktach końcowych w aplikacji funkcji. Ułatwia to opracowywanie, weryfikowanie i wdrażanie aktualizacji funkcji bez wpływu na funkcje działające w środowisku produkcyjnym. Miejsca wdrożenia to funkcja usługi aplikacja systemu Azure Service. Liczba dostępnych miejsc zależy od planu hostingu. Aby uzyskać więcej informacji, zobacz Funkcje miejsc wdrożenia usługi Azure Functions.

Zasób miejsca jest definiowany w taki sam sposób jak zasób aplikacji funkcji (Microsoft.Web/sites), ale zamiast tego należy użyć identyfikatora Microsoft.Web/sites/slots zasobu. Aby zapoznać się z przykładowym wdrożeniem (zarówno w szablonach Bicep, jak i ARM), które tworzy zarówno miejsce produkcyjne, jak i przejściowe w planie Premium, zobacz Aplikacja funkcji platformy Azure z miejscem wdrożenia.

Aby dowiedzieć się, jak przeprowadzić zamianę przy użyciu szablonów, zobacz Automatyzowanie przy użyciu szablonów usługi Resource Manager.

Podczas pracy z wdrożeniami miejsc należy pamiętać o następujących kwestiach:

  • Nie ustawiaj WEBSITE_CONTENTSHARE jawnie ustawienia w definicji miejsca wdrożenia. To ustawienie jest generowane podczas tworzenia aplikacji w miejscu wdrożenia.

  • W przypadku zamiany miejsc niektóre ustawienia aplikacji są uznawane za "lepkie", ponieważ pozostają z miejscem, a nie z wymienianym kodem. Takie ustawienie miejsca można zdefiniować, uwzględniając "slotSetting":true w szablonie konkretną definicję ustawienia aplikacji. Aby uzyskać więcej informacji, zobacz Zarządzanie ustawieniami.

Zabezpieczone wdrożenia

Aplikację funkcji można utworzyć we wdrożeniu, w którym co najmniej jeden z zasobów został zabezpieczony przez integrację z sieciami wirtualnymi. Integracja sieci wirtualnej dla aplikacji funkcji jest definiowana Microsoft.Web/sites/networkConfig przez zasób. Ta integracja zależy zarówno od przywołyanych aplikacji funkcji, jak i zasobów sieci wirtualnej. Aplikacja funkcji może również zależeć od innych zasobów sieci prywatnych, takich jak prywatne punkty końcowe i trasy. Aby uzyskać więcej informacji, zobacz Opcje sieci usługi Azure Functions.

Podczas tworzenia wdrożenia korzystającego z zabezpieczonego konta magazynu należy jawnie ustawić WEBSITE_CONTENTSHARE ustawienie i utworzyć zasób udziału plików o nazwie w tym ustawieniu. Upewnij się, że tworzysz Microsoft.Storage/storageAccounts/fileServices/shares zasób przy użyciu wartości WEBSITE_CONTENTSHARE, jak pokazano w tym przykładzie (plik Bicep szablonu|usługi ARM). Należy również ustawić właściwość vnetContentShareEnabled witryny na wartość true.

Uwaga

Jeśli te ustawienia nie są częścią wdrożenia korzystającego z zabezpieczonego konta magazynu, ten błąd zostanie wyświetlony podczas walidacji wdrożenia: Could not access storage account using provided connection string.

Te projekty udostępniają przykłady szablonów Bicep i ARM dotyczące sposobu wdrażania aplikacji funkcji w sieci wirtualnej, w tym z ograniczeniami dostępu do sieci:

Scenariusz ograniczony opis
Tworzenie aplikacji funkcji z integracją sieci wirtualnej Aplikacja funkcji jest tworzona w sieci wirtualnej z pełnym dostępem do zasobów w tej sieci. Dostęp przychodzący i wychodzący do aplikacji funkcji nie jest ograniczony. Aby uzyskać więcej informacji, zobacz Integracja sieci wirtualnej.
Tworzenie aplikacji funkcji, która uzyskuje dostęp do zabezpieczonego konta magazynu Utworzona aplikacja funkcji używa zabezpieczonego konta magazynu, do którego usługa Functions uzyskuje dostęp przy użyciu prywatnych punktów końcowych. Aby uzyskać więcej informacji, zobacz Ograniczanie konta magazynu do sieci wirtualnej.
Tworzenie aplikacji funkcji i konta magazynu, które używają prywatnych punktów końcowych Dostęp do utworzonej aplikacji funkcji można uzyskać tylko przy użyciu prywatnych punktów końcowych i używa prywatnych punktów końcowych do uzyskiwania dostępu do zasobów magazynu. Aby uzyskać więcej informacji, zobacz Prywatne punkty końcowe.

Ustawienia sieci z ograniczeniami

Może być również konieczne użycie tych ustawień, gdy aplikacja funkcji ma ograniczenia sieci:

Ustawienie Wartość Opis
WEBSITE_CONTENTOVERVNET 1 Ustawienie aplikacji, które umożliwia skalowanie aplikacji funkcji, gdy konto magazynu jest ograniczone do sieci wirtualnej. Aby uzyskać więcej informacji, zobacz Ograniczanie konta magazynu do sieci wirtualnej.
vnetrouteallenabled 1 Ustawienie lokacji, które wymusza cały ruch z aplikacji funkcji do korzystania z sieci wirtualnej. Aby uzyskać więcej informacji, zobacz Regionalna integracja sieci wirtualnej. To ustawienie witryny zastępuje ustawienie WEBSITE_VNET_ROUTE_ALLaplikacji .

Zagadnienia dotyczące ograniczeń sieci

Jeśli ograniczasz dostęp do konta magazynu za pośrednictwem prywatnych punktów końcowych, nie możesz uzyskać dostępu do konta magazynu za pośrednictwem portalu ani żadnego urządzenia spoza sieci wirtualnej. Możesz udzielić dostępu do zabezpieczonego adresu IP lub sieci wirtualnej na koncie magazynu, zarządzając domyślną regułą dostępu do sieci.

Tworzenie szablonu

Eksperci z szablonami Bicep lub ARM mogą ręcznie kodować wdrożenia przy użyciu prostego edytora tekstów. Dla reszty z nas istnieje kilka sposobów, aby proces programowania był łatwiejszy:

  • Visual Studio Code: dostępne są rozszerzenia ułatwiające pracę zarówno z plikami Bicep, jak i szablonami usługi ARM. Możesz użyć tych narzędzi, aby upewnić się, że kod jest poprawny i zapewnia podstawową walidację.

  • Witryna Azure Portal: podczas tworzenia aplikacji funkcji i powiązanych zasobów w portalu końcowy ekran Przeglądanie i tworzenie zawiera link Pobierz szablon automatyzacji .

    Pobierz link szablonu z procesu tworzenia usługi Azure Functions w witrynie Azure Portal.

    Ten link przedstawia szablon usługi ARM wygenerowany na podstawie opcji wybranych w portalu. Chociaż ten szablon może być nieco złożony podczas tworzenia aplikacji funkcji z wieloma nowymi zasobami, może to zapewnić dobre informacje na temat wyglądu szablonu usługi ARM.

Weryfikowanie szablonu

Podczas ręcznego tworzenia pliku szablonu wdrożenia ważne jest zweryfikowanie szablonu przed wdrożeniem. Wszystkie metody wdrażania weryfikują składnię szablonu i zgłaszają validation failed komunikat o błędzie, jak pokazano w poniższym przykładzie sformatowanym w formacie JSON:

{"error":{"code":"InvalidTemplate","message":"Deployment template validation failed: 'The resource 'Microsoft.Web/sites/func-xyz' is not defined in the template. Please see https://aka.ms/arm-template for usage details.'.","additionalInfo":[{"type":"TemplateViolation","info":{"lineNumber":0,"linePosition":0,"path":""}}]}}

Następujące metody mogą służyć do weryfikowania szablonu przed wdrożeniem:

Następujące zadaniedeploymentMode: 'Validation' wdrażania grupy zasobów platformy Azure w wersji 2 powoduje, że usługa Azure Pipelines zweryfikuje szablon.

- task: AzureResourceManagerTemplateDeployment@3
  inputs:
    deploymentScope: 'Resource Group'
    subscriptionId: # Required subscription ID
    action: 'Create Or Update Resource Group'
    resourceGroupName: # Required resource group name
    location: # Required when action == Create Or Update Resource Group
    templateLocation: 'Linked artifact'
    csmFile: # Required when  TemplateLocation == Linked Artifact
    csmParametersFile: # Optional
    deploymentMode: 'Validation'

Możesz również utworzyć testową grupę zasobów, aby znaleźć błędy wstępne i wdrożenia .

Wdrażanie szablonu

Aby wdrożyć plik i szablon Bicep, możesz użyć dowolnego z następujących sposobów:

Przycisk Wdróż na platformie Azure

Uwaga

Ta metoda nie obsługuje obecnie wdrażania plików Bicep.

Zastąp <url-encoded-path-to-azuredeploy-json> ciąg wersją zakodowaną w adresie URL ścieżki pierwotnej azuredeploy.json pliku w usłudze GitHub.

Oto przykład, który używa języka Markdown:

[![Deploy to Azure](https://azuredeploy.net/deploybutton.png)](https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>)

Oto przykład, który używa kodu HTML:

<a href="https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>" target="_blank"><img src="https://azuredeploy.net/deploybutton.png"></a>

Wdrażanie przy użyciu programu PowerShell

Następujące polecenia programu PowerShell tworzą grupę zasobów i wdrażają plik Bicep/szablon usługi ARM, który tworzy aplikację funkcji z wymaganymi zasobami. Aby uruchomić lokalnie, musisz mieć zainstalowany program Azure PowerShell . Uruchom polecenie Connect-AzAccount , aby się zalogować.

# Register Resource Providers if they're not already registered
Register-AzResourceProvider -ProviderNamespace "microsoft.web"
Register-AzResourceProvider -ProviderNamespace "microsoft.storage"

# Create a resource group for the function app
New-AzResourceGroup -Name "MyResourceGroup" -Location 'West Europe'

# Deploy the template
New-AzResourceGroupDeployment -ResourceGroupName "MyResourceGroup" -TemplateFile azuredeploy.json  -Verbose

Aby przetestować to wdrożenie, możesz użyć szablonu takiego jak ten , który tworzy aplikację funkcji w systemie Windows w planie Zużycie.

Następne kroki

Dowiedz się więcej o sposobie tworzenia i konfigurowania usługi Azure Functions.