Sdílet prostřednictvím

Příklad: Vytvoření a nasazení webové aplikace pomocí knihoven Azure

  • Článek

Tento příklad ukazuje, jak pomocí knihoven pro správu sady Azure SDK ve skriptu Pythonu vytvořit a nasadit webovou aplikaci do služby Aplikace Azure Service. Kód aplikace se nasadí z úložiště GitHub.

S knihovnami pro správu (obory názvů začínajícími azure-mgmtnapříklad azure-mgmt-web) můžete psát programy konfigurace a nasazení pro provádění stejných úloh, které můžete provádět prostřednictvím webu Azure Portal, Azure CLI nebo jiných nástrojů pro správu prostředků. Příklady najdete v rychlém startu: Nasazení webové aplikace v Pythonu (Django nebo Flask) do služby Aplikace Azure Service. (Ekvivalentní příkazy Azure CLI jsou uvedeny dále v tomto článku.)

Všechny příkazy v tomto článku fungují stejně v prostředích Bash pro Linux/macOS a Windows, pokud není uvedeno.

1: Nastavení místního vývojového prostředí

Pokud jste to ještě neudělali, nastavte prostředí, ve kterém můžete tento kód spustit. Zde je uvedeno několik možností:

2: Instalace požadovaných balíčků knihovny Azure

Vytvořte soubor s názvem requirements.txt s následujícím obsahem:

azure-mgmt-resource
azure-mgmt-web
azure-identity

V terminálu nebo příkazovém řádku s aktivovaným virtuálním prostředím nainstalujte požadavky:

pip install -r requirements.txt

3: Vytvoření forku ukázkového úložiště

Navštivte a rozvětvujte https://github.com/Azure-Samples/python-docs-hello-world úložiště do svého vlastního účtu GitHubu. Pomocí forku zajistíte, že máte oprávnění k nasazení úložiště do Azure.

Forking the sample repository on GitHub

Pak vytvořte proměnnou prostředí s názvem REPO_URL URL vašeho forku. Ukázkový kód v další části závisí na této proměnné prostředí:

set REPO_URL=<url_of_your_fork>
set AZURE_SUBSCRIPTION_ID=<subscription_id>

4: Napsání kódu pro vytvoření a nasazení webové aplikace

Vytvořte soubor Pythonu s názvem provision_deploy_web_app.py s následujícím kódem. Komentáře vysvětlují podrobnosti kódu. Před spuštěním skriptu nezapomeňte definovat REPO_URL proměnné prostředí a AZURE_SUBSCRIPTION_ID proměnné prostředí.

import random, os
from azure.identity import AzureCliCredential
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.web import WebSiteManagementClient

# Acquire a credential object using CLI-based authentication.
credential = AzureCliCredential()

# Retrieve subscription ID from environment variable
subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]

# Constants we need in multiple places: the resource group name and the region
# in which we provision resources. You can change these values however you want.
RESOURCE_GROUP_NAME = 'PythonAzureExample-WebApp-rg'
LOCATION = "centralus"

# Step 1: Provision the resource group.
resource_client = ResourceManagementClient(credential, subscription_id)

rg_result = resource_client.resource_groups.create_or_update(RESOURCE_GROUP_NAME,
    { "location": LOCATION })

print(f"Provisioned resource group {rg_result.name}")

# For details on the previous code, see Example: Provision a resource group
# at https://docs.microsoft.com/azure/developer/python/azure-sdk-example-resource-group


#Step 2: Provision the App Service plan, which defines the underlying VM for the web app.

# Names for the App Service plan and App Service. We use a random number with the
# latter to create a reasonably unique name. If you've already provisioned a
# web app and need to re-run the script, set the WEB_APP_NAME environment 
# variable to that name instead.
SERVICE_PLAN_NAME = 'PythonAzureExample-WebApp-plan'
WEB_APP_NAME = os.environ.get("WEB_APP_NAME", f"PythonAzureExample-WebApp-{random.randint(1,100000):05}")

# Obtain the client object
app_service_client = WebSiteManagementClient(credential, subscription_id)

# Provision the plan; Linux is the default
poller = app_service_client.app_service_plans.begin_create_or_update(RESOURCE_GROUP_NAME,
    SERVICE_PLAN_NAME,
    {
        "location": LOCATION,
        "reserved": True,
        "sku" : {"name" : "B1"}
    }
)

plan_result = poller.result()

print(f"Provisioned App Service plan {plan_result.name}")


# Step 3: With the plan in place, provision the web app itself, which is the process that can host
# whatever code we want to deploy to it.

poller = app_service_client.web_apps.begin_create_or_update(RESOURCE_GROUP_NAME,
    WEB_APP_NAME,
    {
        "location": LOCATION,
        "server_farm_id": plan_result.id,
        "site_config": {
            "linux_fx_version": "python|3.8"
        }
    }
)

web_app_result = poller.result()

print(f"Provisioned web app {web_app_result.name} at {web_app_result.default_host_name}")

# Step 4: deploy code from a GitHub repository. For Python code, App Service on Linux runs
# the code inside a container that makes certain assumptions about the structure of the code.
# For more information, see How to configure Python apps,
# https://docs.microsoft.com/azure/app-service/containers/how-to-configure-python.
#
# The create_or_update_source_control method doesn't provision a web app. It only sets the
# source control configuration for the app. In this case we're simply pointing to
# a GitHub repository.
#
# You can call this method again to change the repo.

REPO_URL = os.environ["REPO_URL"]

poller = app_service_client.web_apps.begin_create_or_update_source_control(RESOURCE_GROUP_NAME,
    WEB_APP_NAME, 
    { 
        "location": "GitHub",
        "repo_url": REPO_URL,
        "branch": "master",
        "is_manual_integration": True
    }
)

sc_result = poller.result()

print(f"Set source control on web app to {sc_result.branch} branch of {sc_result.repo_url}")

# Step 5: Deploy the code using the repository and branch configured in the previous step.
#
# If you push subsequent code changes to the repo and branch, you must call this method again
# or use another Azure tool like the Azure CLI or Azure portal to redeploy. 
# Note: By default, the method returns None.

app_service_client.web_apps.sync_repository(RESOURCE_GROUP_NAME, WEB_APP_NAME)

print(f"Deploy code")

Tento kód používá ověřování založené na rozhraní příkazového řádku (pomocí AzureCliCredential), protože ukazuje akce, které byste jinak mohli udělat s Azure CLI přímo. V obou případech k ověřování používáte stejnou identitu. V závislosti na vašem prostředí možná budete muset nejprve spustit az login ověření.

Pokud chcete tento kód použít v produkčním skriptu (například k automatizaci správy virtuálních počítačů), použijte DefaultAzureCredential (doporučeno) s metodou založenou na instančním objektu, jak popisuje postup ověřování aplikací Pythonu pomocí služeb Azure.

5: Spuštění skriptu

python provision_deploy_web_app.py

6: Ověření nasazení webové aplikace

Spuštěním následujícího příkazu přejděte na nasazený web:

az webapp browse --name PythonAzureExample-WebApp-12345 --resource-group PythonAzureExample-WebApp-rg

Nahraďte název webové aplikace (--name možnost) a název skupiny prostředků (--resource-group možnost) hodnotami, které jste použili ve skriptu. V prohlížeči by se měla zobrazit zpráva "Hello, World!".

Pokud se očekávaný výstup nezobrazí, počkejte několik minut a zkuste to znovu.

Pokud se očekávaný výstup stále nezobrazuje, postupujte takto:

  1. Přejděte na Azure Portal.
  2. Vyberte skupiny prostředků a najděte skupinu prostředků, kterou jste vytvořili.
  3. Výběrem názvu skupiny prostředků zobrazíte prostředky, které obsahuje. Konkrétně ověřte, že existuje plán služby App Service a služba App Service.
  4. Vyberte službu App Service a pak vyberte Deployment Center.
  5. Výběrem karty protokoly zobrazíte protokoly nasazení.

7: Opětovné nasazení kódu webové aplikace (volitelné)

Skript nastaví prostředky potřebné k hostování webové aplikace a nastaví zdroj nasazení na váš fork pomocí ruční integrace. Při ruční integraci musíte webovou aplikaci aktivovat, aby se stáhla z nakonfigurovaného úložiště a větve.

Skript volá metodu WebSiteManagementClient.web_apps.sync_repository , která aktivuje přijetí změn z webové aplikace. Pokud do úložiště nasdílíte následné změny kódu, můžete kód znovu nasadit vyvoláním tohoto rozhraní API nebo použitím jiných nástrojů Azure, jako je Azure CLI nebo Azure Portal.

Kód můžete nasadit pomocí Azure CLI spuštěním příkazu az webapp deployment source sync :

az webapp deployment source sync --name PythonAzureExample-WebApp-12345 --resource-group PythonAzureExample-WebApp-rg

Nahraďte název webové aplikace (--name možnost) a název skupiny prostředků (--resource-group možnost) hodnotami, které jste použili ve skriptu.

Nasazení kódu z webu Azure Portal:

  1. Přejděte na Azure Portal.
  2. Vyberte skupiny prostředků a najděte skupinu prostředků, kterou jste vytvořili.
  3. Výběrem názvu skupiny prostředků zobrazíte prostředky, které obsahuje. Konkrétně ověřte, že existuje plán služby App Service a služba App Service.
  4. Vyberte službu App Service a pak vyberte Deployment Center.
  5. V horní nabídce vyberte Synchronizovat a nasaďte kód.

8: Vyčištění prostředků

az group delete --name PythonAzureExample-WebApp-rg --no-wait

Pokud v tomto příkladu nepotřebujete zachovat skupinu prostředků vytvořenou v tomto příkladu , spusťte příkaz az group delete . Ve vašem předplatném se za skupiny prostředků neúčtují žádné průběžné poplatky, ale je vhodné vyčistit jakoukoli skupinu, kterou aktivně nepoužíváte. Argument --no-wait umožňuje, aby se příkaz vrátil okamžitě místo čekání na dokončení operace.

Metodu ResourceManagementClient.resource_groups.begin_delete můžete použít také k odstranění skupiny prostředků z kódu.

Referenční informace: Ekvivalentní příkazy Azure CLI

Následující příkazy Azure CLI dokončí stejné kroky zřizování jako skript Pythonu:

rem Replace <your_github_user_name> with the account name of the fork.

set repoUrl=https://github.com/<your_github_user_name>/python-docs-hello-world
set appName=PythonAzureExample-WebApp-%random%

az group create -l centralus -n PythonAzureExample-WebApp-rg

az appservice plan create -n PythonAzureExample-WebApp-plan -g PythonAzureExample-WebApp-rg ^
     --is-linux --sku F1

echo Creating app: %appName%

az webapp create -g PythonAzureExample-WebApp-rg -n %appName% ^
    --plan PythonAzureExample-WebApp-plan --runtime "python|3.8"

rem You can use --deployment-source-url with the first create command. It is shown here
rem to match the sequence of the Python code.

az webapp create -n %appName% -g PythonAzureExample-WebApp-rg ^
    --plan PythonAzureExample-WebApp-plan --runtime "python|3.8" ^
    --deployment-source-url %repoUrl% 

rem The previous command sets up External Git deployment from the specified repository. This 
rem command triggers a pull from the repository.

az webapp deployment source sync --name %appName% --resource-group PythonAzureExample-WebApp-rg

Viz také