Aracılığıyla paylaş

Azure İşlevleri Python geliştirici kılavuzu

  • Makale

Bu kılavuz, Python kullanarak Azure İşlevleri geliştirmeye giriş niteliğindedir. Makalede, Azure İşlevleri geliştiriciler kılavuzunu okuduğunuz varsayılır.

Önemli

Bu makale, Azure İşlevleri'da Python için hem v1 hem de v2 programlama modelini destekler. Python v1 modeli işlevleri tanımlamak için bir functions.json dosyası kullanır ve yeni v2 modeli bunun yerine dekoratör tabanlı bir yaklaşım kullanmanıza olanak tanır. Bu yeni yaklaşım daha basit bir dosya yapısına neden olur ve daha kod odaklıdır. Bu yeni programlama modeli hakkında bilgi edinmek için makalenin üst kısmındaki v2 seçicisini seçin.

Python geliştiricisi olarak şu konularla da ilgilenebilirsiniz:

Dağıtım seçenekleri

Her iki Python İşlevi programlama modeli de aşağıdaki ortamlardan birinde yerel geliştirmeyi destekler:

Python v2 programlama modeli:

Python v1 programlama modeli:

Azure portalında Python v1 işlevleri de oluşturabilirsiniz.

İpucu

Python tabanlı Azure işlevlerinizi Windows üzerinde yerel olarak geliştirebilmenize rağmen, Python yalnızca Azure'da çalışırken Linux tabanlı barındırma planında desteklenir. Daha fazla bilgi için desteklenen işletim sistemi/çalışma zamanı bileşimleri listesine bakın.

Programlama modeli

Azure İşlevleri, Python betiğinizde girişi işleyen ve çıkış üreten durum bilgisi olmayan bir yöntem işlevi olmasını bekler. Varsayılan olarak, çalışma zamanı yönteminin __init__.py dosyasında çağrılan main() genel bir yöntem olarak uygulanmasını bekler. Alternatif bir giriş noktası da belirtebilirsiniz.

function.json dosyasında tanımlanan özelliğini kullanan name yöntem öznitelikleri aracılığıyla tetikleyicilerden ve bağlamalardan işleve veri bağlarsınız. Örneğin, aşağıdaki function.json dosyasında adlı reqbir HTTP isteği tarafından tetiklenen basit bir işlev açıklanır:

{
    "scriptFile": "__init__.py",
    "bindings": [
        {
            "authLevel": "function",
            "type": "httpTrigger",
            "direction": "in",
            "name": "req",
            "methods": [
                "get",
                "post"
            ]
        },
        {
            "type": "http",
            "direction": "out",
            "name": "$return"
        }
    ]
}

Bu tanıma bağlı olarak, işlev kodunu içeren __init__.py dosyası aşağıdaki örneğe benzer olabilir:

def main(req):
    user = req.params.get('user')
    return f'Hello, {user}!'

Ayrıca Python türü ek açıklamalarını kullanarak işlevde öznitelik türlerini ve dönüş türünü açıkça bildirebilirsiniz. Bunu yapmak, birçok Python kod düzenleyicisi tarafından sağlanan IntelliSense ve otomatik tamamlama özelliklerini kullanmanıza yardımcı olur.

import azure.functions

def main(req: azure.functions.HttpRequest) -> str:
    user = req.params.get('user')
    return f'Hello, {user}!'

Giriş ve çıkışları yöntemlerinize bağlamak için azure.functions.* paketine dahil edilen Python ek açıklamalarını kullanın.

Azure İşlevleri, Python betiğinizde girişi işleyen ve çıkış üreten durum bilgisi olmayan bir yöntem işlevi olmasını bekler. Çalışma zamanı varsayılan olarak yönteminin function_app.py dosyasında genel bir yöntem olarak uygulanmasını bekler.

Tetikleyiciler ve bağlamalar, dekoratör tabanlı bir yaklaşımda bir işlevde bildirilebilir ve kullanılabilir. Bunlar, işlevlerle aynı dosyada function_app.py tanımlanır. Örneğin, aşağıdaki function_app.py dosyası BIR HTTP isteği tarafından bir işlev tetikleyicisini temsil eder.

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req):
    user = req.params.get("user")
    return f"Hello, {user}!"

Ayrıca Python türü ek açıklamalarını kullanarak işlevde öznitelik türlerini ve dönüş türünü açıkça bildirebilirsiniz. Bunu yapmak, birçok Python kod düzenleyicisi tarafından sağlanan IntelliSense ve otomatik tamamlama özelliklerini kullanmanıza yardımcı olur.

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req: func.HttpRequest) -> str:
    user = req.params.get("user")
    return f"Hello, {user}!"

v2 modeliyle ilgili bilinen sınırlamalar ve bunların geçici çözümleri hakkında bilgi edinmek için bkz. Azure İşlevleri Python hatalarını giderme.

Alternatif giriş noktası

İsteğe bağlı olarak function.json dosyasında ve entryPoint özelliklerini belirterek scriptFile bir işlevin varsayılan davranışını değiştirebilirsiniz. Örneğin, aşağıdaki function.json çalışma zamanına azure işlevinizin giriş noktası olarak main.py dosyasındaki yöntemini kullanmasını customentry() söyler.

{
  "scriptFile": "main.py",
  "entryPoint": "customentry",
  "bindings": [
      ...
  ]
}

Giriş noktası yalnızca function_app.py dosyasındadır. Ancak, şemaları kullanarak veya içeri aktararak proje içindeki işlevlere function_app.py başvurabilirsiniz.

Klasör yapısı

Python işlevleri projesi için önerilen klasör yapısı aşağıdaki örneğe benzer:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - my_first_function/
 | | - __init__.py
 | | - function.json
 | | - example.py
 | - my_second_function/
 | | - __init__.py
 | | - function.json
 | - shared_code/
 | | - __init__.py
 | | - my_first_helper_function.py
 | | - my_second_helper_function.py
 | - tests/
 | | - test_my_second_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

project_root> ana proje klasörü <aşağıdaki dosyaları içerebilir:

  • local.settings.json: Yerel olarak çalışırken uygulama ayarlarını ve bağlantı dizesi depolamak için kullanılır. Bu dosya Azure'da yayımlanmaz. Daha fazla bilgi için bkz . local.settings.file.
  • requirements.txt: Azure'da yayımlarken sistemin yüklemiş olduğu Python paketlerinin listesini içerir.
  • host.json: İşlev uygulaması örneğindeki tüm işlevleri etkileyen yapılandırma seçeneklerini içerir. Bu dosya Azure'da yayımlanır. Yerel olarak çalıştırılırken tüm seçenekler desteklenmez. Daha fazla bilgi edinmek için bkz . host.json.
  • .vscode/: (İsteğe bağlı) Depolanan Visual Studio Code yapılandırmasını içerir. Daha fazla bilgi edinmek için bkz . Visual Studio Code ayarları.
  • .venv/: (İsteğe bağlı) Yerel geliştirme tarafından kullanılan bir Python sanal ortamı içerir.
  • Dockerfile: (İsteğe bağlı) Projenizi özel bir kapsayıcıda yayımlarken kullanılır.
  • tests/: (İsteğe bağlı) İşlev uygulamanızın test çalışmalarını içerir.
  • .funcignore: (İsteğe bağlı) Azure'da yayımlanmaması gereken dosyaları bildirir. Bu dosya genellikle düzenleyici ayarınızı yoksaymak için .vscode/, yerel Python sanal ortamını yoksaymak için .venv/, test çalışmalarını yoksaymak için testler/ ve yerel uygulama ayarlarının yayımlanmasını önlemek için local.settings.json içerir.

Her işlevin kendi kod dosyası ve bağlama yapılandırma dosyası function.json.

Python işlevleri projesi için önerilen klasör yapısı aşağıdaki örneğe benzer:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - function_app.py
 | - additional_functions.py
 | - tests/
 | | - test_my_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

project_root> ana proje klasörü <aşağıdaki dosyaları içerebilir:

  • .venv/: (İsteğe bağlı) Yerel geliştirme tarafından kullanılan bir Python sanal ortamı içerir.
  • .vscode/: (İsteğe bağlı) Depolanan Visual Studio Code yapılandırmasını içerir. Daha fazla bilgi edinmek için bkz . Visual Studio Code ayarları.
  • function_app.py: Tüm işlevler ve bunların ilgili tetikleyicileri ve bağlamaları için varsayılan konum.
  • additional_functions.py: (İsteğe bağlı) şemalar aracılığıyla function_app.py başvuruda bulunılan işlevler içeren diğer Python dosyaları (genellikle mantıksal gruplandırma için).
  • tests/: (İsteğe bağlı) İşlev uygulamanızın test çalışmalarını içerir.
  • .funcignore: (İsteğe bağlı) Azure'da yayımlanmaması gereken dosyaları bildirir. Bu dosya genellikle düzenleyici ayarınızı yoksaymak için .vscode/ içerir, yerel Python sanal ortamını yoksaymak için .venv/ , test çalışmalarını yoksaymak için testler/ ve yerel uygulama ayarlarının yayımlanmasını önlemek için local.settings.json .
  • host.json: İşlev uygulaması örneğindeki tüm işlevleri etkileyen yapılandırma seçeneklerini içerir. Bu dosya Azure'da yayımlanır. Yerel olarak çalıştırılırken tüm seçenekler desteklenmez. Daha fazla bilgi edinmek için bkz . host.json.
  • local.settings.json: Yerel olarak çalışırken uygulama ayarlarını ve bağlantı dizesi depolamak için kullanılır. Bu dosya Azure'da yayımlanmaz. Daha fazla bilgi için bkz . local.settings.file.
  • requirements.txt: Sistemin Azure'da yayımlandığında yüklemiş olduğu Python paketlerinin listesini içerir.
  • Dockerfile: (İsteğe bağlı) Projenizi özel bir kapsayıcıda yayımlarken kullanılır.

Projenizi Azure'daki bir işlev uygulamasına dağıttığınızda, project_root ana proje klasörünün <>tüm içeriği pakete dahil edilmelidir, ancak klasörün kendisi dahil edilmemelidir; bu da host.json paket kökünde olması gerektiği anlamına gelir. Testlerinizi diğer işlevlerle birlikte bir klasörde tutmanızı öneririz (bu örnekte testler /). Daha fazla bilgi için bkz . Birim testi.

Veritabanına bağlan

Azure İşlevleri ile iyi tümleşirIoT, e-ticaret, oyun vb. gibi birçok kullanım örneği için Azure Cosmos DB

Örneğin, olay kaynağını belirleme için iki hizmet, Azure Cosmos DB'nin değişiklik akışı işlevselliği kullanılarak güç olay odaklı mimarilerle tümleştirilir. Değişiklik akışı, aşağı akış mikro hizmetlerine eklemeleri ve güncelleştirmeleri güvenilir ve artımlı olarak okuma olanağı sağlar (örneğin, sipariş olayları). Bu işlevsellik, durum değiştiren olaylar için ileti aracısı olarak kalıcı bir olay deposu sağlamak ve birçok mikro hizmet arasında (sunucusuz Azure İşlevleri olarak uygulanabilir) sipariş işleme iş akışını yönlendirmek için kullanılabilir.

Azure Cosmos DB sipariş işlem hattı başvuru mimarisi

Azure Cosmos DB'ye bağlanmak için önce bir hesap, veritabanı ve kapsayıcı oluşturun. Ardından bu örnekte olduğu gibi tetikleyici ve bağlamaları kullanarak işlev kodunuzu Azure Cosmos DB'ye bağlayabilirsiniz.

Daha karmaşık uygulama mantığı uygulamak için Cosmos DB için Python kitaplığını da kullanabilirsiniz. Zaman uyumsuz G/Ç uygulaması şöyle görünür:

pip install azure-cosmos
pip install aiohttp

from azure.cosmos.aio import CosmosClient
from azure.cosmos import exceptions
from azure.cosmos.partition_key import PartitionKey
import asyncio

# Replace these values with your Cosmos DB connection information
endpoint = "https://azure-cosmos-nosql.documents.azure.com:443/"
key = "master_key"
database_id = "cosmicwerx"
container_id = "cosmicontainer"
partition_key = "/partition_key"

# Set the total throughput (RU/s) for the database and container
database_throughput = 1000

# Singleton CosmosClient instance
client = CosmosClient(endpoint, credential=key)

# Helper function to get or create database and container
async def get_or_create_container(client, database_id, container_id, partition_key):
    database = await client.create_database_if_not_exists(id=database_id)
    print(f'Database "{database_id}" created or retrieved successfully.')

    container = await database.create_container_if_not_exists(id=container_id, partition_key=PartitionKey(path=partition_key))
    print(f'Container with id "{container_id}" created')
 
    return container
 
async def create_products():
    container = await get_or_create_container(client, database_id, container_id, partition_key)
    for i in range(10):
        await container.upsert_item({
            'id': f'item{i}',
            'productName': 'Widget',
            'productModel': f'Model {i}'
        })
 
async def get_products():
    items = []
    container = await get_or_create_container(client, database_id, container_id, partition_key)
    async for item in container.read_all_items():
        items.append(item)
    return items

async def query_products(product_name):
    container = await get_or_create_container(client, database_id, container_id, partition_key)
    query = f"SELECT * FROM c WHERE c.productName = '{product_name}'"
    items = []
    async for item in container.query_items(query=query, enable_cross_partition_query=True):
        items.append(item)
    return items

async def main():
    await create_products()
    all_products = await get_products()
    print('All Products:', all_products)

    queried_products = await query_products('Widget')
    print('Queried Products:', queried_products)

if __name__ == "__main__":
    asyncio.run(main())

Blueprints

Python v2 programlama modeli şema kavramını tanıtır. Şema, işlevleri çekirdek işlev uygulamasının dışında kaydetmek için örneği oluşturulmuş yeni bir sınıftır. Şema örneklerine kaydedilen işlevler, işlev çalışma zamanı tarafından doğrudan dizine kaydedilmez. Bu şema işlevlerini dizine almak için işlev uygulamasının şema örneklerinden işlevleri kaydetmesi gerekir.

Şemaları kullanmak aşağıdaki avantajları sağlar:

  • İşlev uygulamasını modüler bileşenlere ayırmanıza olanak tanır. Bu sayede birden çok Python dosyasında işlev tanımlayabilir ve bunları dosya başına farklı bileşenlere bölebilirsiniz.
  • Kendi API'lerinizi oluşturmak ve yeniden kullanmak için genişletilebilir genel işlev uygulaması arabirimleri sağlar.

Aşağıdaki örnekte şemaların nasıl kullanılacağı gösterilmektedir:

İlk olarak, bir http_blueprint.py dosyasında, http ile tetiklenen bir işlev önce tanımlanır ve şema nesnesine eklenir.

import logging 

import azure.functions as func 

bp = func.Blueprint() 

@bp.route(route="default_template") 
def default_template(req: func.HttpRequest) -> func.HttpResponse: 
    logging.info('Python HTTP trigger function processed a request.') 

    name = req.params.get('name') 
    if not name: 
        try: 
            req_body = req.get_json() 
        except ValueError: 
            pass 
        else: 
            name = req_body.get('name') 

    if name: 
        return func.HttpResponse( 
            f"Hello, {name}. This HTTP-triggered function " 
            f"executed successfully.") 
    else: 
        return func.HttpResponse( 
            "This HTTP-triggered function executed successfully. " 
            "Pass a name in the query string or in the request body for a" 
            " personalized response.", 
            status_code=200 
        )

Ardından, function_app.py dosyasında şema nesnesi içeri aktarılır ve işlevleri işlev uygulamasına kaydedilir.

import azure.functions as func 
from http_blueprint import bp

app = func.FunctionApp() 

app.register_functions(bp)

Not

Dayanıklı İşlevler şemaları da destekler. Dayanıklı İşlevler uygulamalarına yönelik şemalar oluşturmak için burada gösterildiği gibi sınıfını kullanarak azure-functions-durable Blueprint düzenleme, etkinlik ve varlık tetikleyicilerinizi ve istemci bağlamalarınızı kaydedin. Sonuçta elde edilen şema normal şekilde kaydedilebilir. Örnek için örneğimize bakın.

İçeri aktarma davranışı

Hem mutlak hem de göreli başvuruları kullanarak işlev kodunuzda modülleri içeri aktarabilirsiniz. Daha önce açıklanan klasör yapısına bağlı olarak, aşağıdaki içeri aktarmalar project_root\my_first_function>\__init__.py işlev dosyasının <içinden çalışır:

from shared_code import my_first_helper_function #(absolute)

import shared_code.my_second_helper_function #(absolute)

from . import example #(relative)

Not

Mutlak içeri aktarma söz dizimi kullanırken, shared_code/ klasörünün Python paketi olarak işaretlemek için bir __init__.py dosyası içermesi gerekir.

Aşağıdaki __app__ içeri aktarma ve üst düzey göreli içeri aktarma işlemleri, statik tür denetleyicisi tarafından desteklenmediğinden ve Python test çerçeveleri tarafından desteklenmediğinden kullanım dışıdır:

from __app__.shared_code import my_first_helper_function #(deprecated __app__ import)

from ..shared_code import my_first_helper_function #(deprecated beyond top-level relative import)

Tetikleyiciler ve girişler

Girişler Azure İşlevleri iki kategoriye ayrılır: tetikleyici girişi ve diğer girişler. function.json dosyasında farklı olsalar da Python kodunda kullanımları aynıdır. Tetikleyici ve giriş kaynakları için bağlantı dizeleri veya gizli diziler, yerel olarak çalıştırılırken local.settings.json dosyasındaki değerlerle eşler ve Azure'da çalışırken uygulama ayarlarına eşler.

Örneğin, aşağıdaki kod iki giriş arasındaki farkı gösterir:

// function.json
{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous",
      "route": "items/{id}"
    },
    {
      "name": "obj",
      "direction": "in",
      "type": "blob",
      "path": "samples/{id}",
      "connection": "STORAGE_CONNECTION_STRING"
    }
  ]
}

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION_STRING": "<AZURE_STORAGE_CONNECTION_STRING>",
    "AzureWebJobsStorage": "<azure-storage-connection-string>"
  }
}

# __init__.py
import azure.functions as func
import logging

def main(req: func.HttpRequest, obj: func.InputStream):
    logging.info(f'Python HTTP-triggered function processed: {obj.read()}')

İşlev çağrıldığında HTTP isteği işlevine olarak reqgeçirilir. Azure Blob Depolama hesabından yol URL'sindeki kimliğe göre bir giriş alınır ve işlev gövdesinde olduğu gibi obj kullanılabilir hale getirilir. Burada, belirtilen depolama hesabı uygulama ayarında CONNECTION_STRING bulunan bağlantı dizesi.

Girişler Azure İşlevleri iki kategoriye ayrılır: tetikleyici girişi ve diğer girişler. Farklı dekoratörler kullanılarak tanımlanmış olsalar da Python kodunda kullanımları benzerdir. Tetikleyici ve giriş kaynakları için bağlantı dizeleri veya gizli diziler, yerel olarak çalıştırılırken local.settings.json dosyasındaki değerlerle eşler ve Azure'da çalışırken uygulama ayarlarına eşler.

Örneğin aşağıdaki kodda Blob Depolama giriş bağlamasının nasıl tanımlanacağı gösterilmektedir:

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "STORAGE_CONNECTION_STRING": "<AZURE_STORAGE_CONNECTION_STRING>",
    "AzureWebJobsStorage": "<azure-storage-connection-string>"
  }
}

# function_app.py
import azure.functions as func
import logging

app = func.FunctionApp()

@app.route(route="req")
@app.read_blob(arg_name="obj", path="samples/{id}", 
               connection="STORAGE_CONNECTION_STRING")
def main(req: func.HttpRequest, obj: func.InputStream):
    logging.info(f'Python HTTP-triggered function processed: {obj.read()}')

İşlev çağrıldığında HTTP isteği işlevine olarak reqgeçirilir. Azure Blob Depolama hesabından yol URL'sindeki kimliğe göre bir giriş alınır ve işlev gövdesinde olduğu gibi obj kullanılabilir hale getirilir. Burada, belirtilen depolama hesabı uygulama ayarında STORAGE_CONNECTION_STRING bulunan bağlantı dizesi.

Yoğun veri bağlama işlemleri için ayrı bir depolama hesabı kullanmak isteyebilirsiniz. Daha fazla bilgi için bkz . Depolama hesabı kılavuzu.

SDK türü bağlamaları (önizleme)

Belirli tetikleyiciler ve bağlamalar için, temel alınan Azure SDK'ları ve çerçeveleri tarafından uygulanan veri türleriyle çalışabilirsiniz. Bu SDK türü bağlamaları , bağlama verilerini temel alınan hizmet SDK'sını kullanıyor gibi etkileşim kurmanıza olanak sağlar.

Önemli

SDK türü bağlamaları desteği için Python v2 programlama modeli gerekir.

İşlevler, temel BlobClient alınan türü kullanarak blob verileriyle çalışmanıza olanak tanıyan Azure Blob depolama için Python SDK türü bağlamalarını destekler.

Önemli

Python için SDK türü bağlama desteği şu anda önizleme aşamasındadır:

  • Python v2 programlama modelini kullanmanız gerekir.
  • Şu anda yalnızca zaman uyumlu SDK türleri desteklenmektedir.

Önkoşullar

Blob depolama uzantısı için SDK türü bağlamalarını etkinleştirme

  1. azurefunctions-extensions-bindings-blob Uzantı paketini projedeki requirements.txt dosyaya ekleyin; en azından şu paketleri içermelidir:

    azure-functions
azurefunctions-extensions-bindings-blob

  2. Bu kodu projedeki dosyaya function_app.py ekleyin ve SDK türü bağlamalarını içeri aktarır:

    import azurefunctions.extensions.bindings.blob as blob

SDK türü bağlama örnekleri

Bu örnekte BlobClient , hem Blob depolama tetikleyicisinden (blob_trigger) hem de http tetikleyicisi üzerindeki giriş bağlamasından (blob_input):

import logging

import azure.functions as func
import azurefunctions.extensions.bindings.blob as blob

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.blob_trigger(
    arg_name="client", path="PATH/TO/BLOB", connection="AzureWebJobsStorage"
)
def blob_trigger(client: blob.BlobClient):
    logging.info(
        f"Python blob trigger function processed blob \n"
        f"Properties: {client.get_blob_properties()}\n"
        f"Blob content head: {client.download_blob().read(size=1)}"
    )


@app.route(route="file")
@app.blob_input(
    arg_name="client", path="PATH/TO/BLOB", connection="AzureWebJobsStorage"
)
def blob_input(req: func.HttpRequest, client: blob.BlobClient):
    logging.info(
        f"Python blob input function processed blob \n"
        f"Properties: {client.get_blob_properties()}\n"
        f"Blob content head: {client.download_blob().read(size=1)}"
    )
    return "ok"

Python uzantıları deposunda Blob depolama için diğer SDK türü bağlama örneklerini görüntüleyebilirsiniz:

HTTP akışları (önizleme)

HTTP akışları, işlevlerinizde etkinleştirilmiş FastAPI isteği ve yanıt API'lerini kullanarak HTTP uç noktalarınızdan verileri kabul etmenizi ve döndürmenizi sağlar. Bu API'ler, konağın bir iletinin tamamını belleğe okumak yerine HTTP iletilerindeki büyük verileri öbekler halinde işlemesine olanak tanır.

Bu özellik, büyük veri akışını, OpenAI tümleştirmelerini işlemeyi, dinamik içerik sunup HTTP üzerinden gerçek zamanlı etkileşimler gerektiren diğer temel HTTP senaryolarını desteklemeyi mümkün kılar. FastAPI yanıt türlerini HTTP akışlarıyla da kullanabilirsiniz. HTTP akışları olmadan, HTTP isteklerinizin ve yanıtlarınızın boyutu, tüm ileti yükleri bellekte işlenirken karşılaşılabilecek bellek kısıtlamalarıyla sınırlıdır.

Önemli

HTTP akışları desteği için Python v2 programlama modeli gerekir.

Önemli

Python için HTTP akışları desteği şu anda önizleme aşamasındadır ve Python v2 programlama modelini kullanmanızı gerektirir.

Önkoşullar

HTTP akışlarını etkinleştirme

HTTP akışları varsayılan olarak devre dışı bırakılır. Bu özelliği uygulama ayarlarınızda etkinleştirmeniz ve ayrıca kodunuzu FastAPI paketini kullanacak şekilde güncelleştirmeniz gerekir. HTTP akışlarını etkinleştirirken işlev uygulamasının varsayılan olarak HTTP akışını kullanacağını ve özgün HTTP işlevinin çalışmayacağını unutmayın.

  1. azurefunctions-extensions-http-fastapi Uzantı paketini projedeki requirements.txt dosyaya ekleyin; en azından şu paketleri içermelidir:

    azure-functions
azurefunctions-extensions-http-fastapi

  2. Bu kodu projedeki dosyaya function_app.py ekleyin. Bu kod, FastAPI uzantısını içeri aktarır:

    from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

  3. Azure'a dağıttığınızda, işlev uygulamanıza aşağıdaki uygulama ayarını ekleyin:

    "PYTHON_ENABLE_INIT_INDEXING": "1"

    Linux Tüketimi'ne dağıtıyorsanız,

    "PYTHON_ISOLATE_WORKER_DEPENDENCIES": "1"

    Yerel olarak çalışırken bu ayarları local.settings.json proje dosyasına da eklemeniz gerekir.

HTTP akışları örnekleri

HTTP akış özelliğini etkinleştirdikten sonra, HTTP üzerinden veri akışı sağlayan işlevler oluşturabilirsiniz.

Bu örnek, HTTP yanıt verilerinin akışını sağlayan HTTP ile tetiklenen bir işlevdir. Gerçek zamanlı görselleştirme için işlem hattı üzerinden olay verileri gönderme veya büyük veri kümelerindeki anomalileri algılama ve anlık bildirimler sağlama gibi senaryoları desteklemek için bu özellikleri kullanabilirsiniz.

import time

import azure.functions as func
from azurefunctions.extensions.http.fastapi import Request, StreamingResponse

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)


def generate_sensor_data():
    """Generate real-time sensor data."""
    for i in range(10):
        # Simulate temperature and humidity readings
        temperature = 20 + i
        humidity = 50 + i
        yield f"data: {{'temperature': {temperature}, 'humidity': {humidity}}}\n\n"
        time.sleep(1)


@app.route(route="stream", methods=[func.HttpMethod.GET])
async def stream_sensor_data(req: Request) -> StreamingResponse:
    """Endpoint to stream real-time sensor data."""
    return StreamingResponse(generate_sensor_data(), media_type="text/event-stream")

Bu örnek, bir istemciden gerçek zamanlı olarak akış verilerini alan ve işleyen HTTP ile tetiklenen bir işlevdir. Sürekli veri akışlarını işleme ve IoT cihazlarından olay verilerini işleme gibi senaryolar için yararlı olabilecek akış karşıya yükleme özelliklerini gösterir.

import azure.functions as func
from azurefunctions.extensions.http.fastapi import JSONResponse, Request

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)


@app.route(route="streaming_upload", methods=[func.HttpMethod.POST])
async def streaming_upload(req: Request) -> JSONResponse:
    """Handle streaming upload requests."""
    # Process each chunk of data as it arrives
    async for chunk in req.stream():
        process_data_chunk(chunk)

    # Once all data is received, return a JSON response indicating successful processing
    return JSONResponse({"status": "Data uploaded and processed successfully"})


def process_data_chunk(chunk: bytes):
    """Process each data chunk."""
    # Add custom processing logic here
    pass

HTTP akışlarını çağırma

bir işlevin FastAPI uç noktalarına akış çağrıları yapmak için HTTP istemci kitaplığı kullanmanız gerekir. Kullandığınız istemci aracı veya tarayıcı, akışı yerel olarak desteklemeyebilir veya yalnızca ilk veri öbeklerini döndürebilir.

Akış verilerini bir HTTP uç noktasına göndermek için bunun gibi bir istemci betiği kullanabilirsiniz:

import httpx # Be sure to add 'httpx' to 'requirements.txt'
import asyncio

async def stream_generator(file_path):
    chunk_size = 2 * 1024  # Define your own chunk size
    with open(file_path, 'rb') as file:
        while chunk := file.read(chunk_size):
            yield chunk
            print(f"Sent chunk: {len(chunk)} bytes")

async def stream_to_server(url, file_path):
    timeout = httpx.Timeout(60.0, connect=60.0)
    async with httpx.AsyncClient(timeout=timeout) as client:
        response = await client.post(url, content=stream_generator(file_path))
        return response

async def stream_response(response):
    if response.status_code == 200:
        async for chunk in response.aiter_raw():
            print(f"Received chunk: {len(chunk)} bytes")
    else:
        print(f"Error: {response}")

async def main():
    print('helloworld')
    # Customize your streaming endpoint served from core tool in variable 'url' if different.
    url = 'http://localhost:7071/api/streaming_upload'
    file_path = r'<file path>'

    response = await stream_to_server(url, file_path)
    print(response)

if __name__ == "__main__":
    asyncio.run(main())

Çıkışlar

Çıkış hem dönüş değeri hem de çıkış parametreleriyle ifade edilebilir. Yalnızca bir çıkış varsa, dönüş değerini kullanmanızı öneririz. Birden çok çıkış için çıkış parametrelerini kullanmanız gerekir.

Bir işlevin dönüş değerini çıkış bağlamasının değeri olarak kullanmak için bağlamanın name özelliği function.json dosyasında olarak ayarlanmalıdır $return .

Birden çok çıkış üretmek için, bağlamaya set() azure.functions.Out bir değer atamak için arabirimi tarafından sağlanan yöntemini kullanın. Örneğin, aşağıdaki işlev kuyruğa ileti göndererek bir HTTP yanıtı döndürebilir.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "msg",
      "direction": "out",
      "type": "queue",
      "queueName": "outqueue",
      "connection": "STORAGE_CONNECTION_STRING"
    },
    {
      "name": "$return",
      "direction": "out",
      "type": "http"
    }
  ]
}

import azure.functions as func

def main(req: func.HttpRequest,
         msg: func.Out[func.QueueMessage]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

Çıkış hem dönüş değeri hem de çıkış parametreleriyle ifade edilebilir. Yalnızca bir çıkış varsa, dönüş değerini kullanmanızı öneririz. Birden çok çıkış için çıkış parametrelerini kullanmanız gerekir.

Birden çok çıkış üretmek için, bağlamaya set() azure.functions.Out bir değer atamak için arabirimi tarafından sağlanan yöntemini kullanın. Örneğin, aşağıdaki işlev kuyruğa ileti göndererek bir HTTP yanıtı döndürebilir.

# function_app.py
import azure.functions as func

app = func.FunctionApp()

@app.write_blob(arg_name="msg", path="output-container/{name}",
                connection="CONNECTION_STRING")
def test_function(req: func.HttpRequest,
                  msg: func.Out[str]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

Günlük Kaydı

Azure İşlevleri çalışma zamanı günlükçüsünü erişim, işlev uygulamanızdaki bir kök logging işleyici aracılığıyla kullanılabilir. Bu günlükçü Application Insights'a bağlıdır ve işlev yürütmesi sırasında oluşan uyarıları ve hataları bayrakla işaretlemenize olanak tanır.

Aşağıdaki örnek, işlev bir HTTP tetikleyicisi aracılığıyla çağrıldığında bir bilgi iletisi günlüğe kaydeder.

import logging

def main(req):
    logging.info('Python HTTP trigger function processed a request.')

Konsola farklı izleme düzeylerinde yazmanızı sağlayan daha fazla günlük yöntemi vardır:

Metot Açıklama
critical(_message_) Kök günlükçüde KRITIK düzeyine sahip bir ileti yazar.
error(_message_) Kök günlükçüde hata düzeyine sahip bir ileti yazar.
warning(_message_) Kök günlükçüde UYARI düzeyine sahip bir ileti yazar.
info(_message_) Kök günlükçüde düzey BİlGİ içeren bir ileti yazar.
debug(_message_) Kök günlükçüde hata ayıklama düzeyine sahip bir ileti yazar.

Günlüğe kaydetme hakkında daha fazla bilgi edinmek için bkz. İzleme Azure İşlevleri.

Oluşturulan iş parçacıklarından günlüğe kaydetme

Oluşturduğunuz iş parçacıklarından gelen günlükleri görmek için işlevin context imzasına bağımsız değişkenini ekleyin. Bu bağımsız değişken, yerel invocation_idbir depolayan bir öznitelik thread_local_storage içerir. Bağlamın değiştirildiğinden emin olmak için bu, işlevin geçerli invocation_id değerine ayarlanabilir.

import azure.functions as func
import logging
import threading


def main(req, context):
    logging.info('Python HTTP trigger function processed a request.')
    t = threading.Thread(target=log_function, args=(context,))
    t.start()


def log_function(context):
    context.thread_local_storage.invocation_id = context.invocation_id
    logging.info('Logging from thread.')

Özel telemetriyi günlüğe kaydetme

varsayılan olarak, İşlevler çalışma zamanı işlevleriniz tarafından oluşturulan günlükleri ve diğer telemetri verilerini toplar. Bu telemetri, Application Insights'ta izleme olarak sona erer. Bazı Azure hizmetleri için istek ve bağımlılık telemetrisi de tetikleyiciler ve bağlamalar tarafından varsayılan olarak toplanır.

Bağlamaların dışında özel istek ve özel bağımlılık telemetrisi toplamak için OpenCensus Python Uzantıları'nı kullanabilirsiniz. Bu uzantı, Application Insights örneğine özel telemetri verileri gönderir. Desteklenen uzantıların listesini OpenCensus deposunda bulabilirsiniz.

Not

OpenCensus Python uzantılarını kullanmak için olarak ayarlayarak PYTHON_ENABLE_WORKER_EXTENSIONS 1işlev uygulamanızda Python çalışan uzantılarını etkinleştirmeniz gerekir. Ayrıca, uygulama ayarlarınız yoksa, bu ayarı uygulama ayarlarınıza ekleyerek APPLICATIONINSIGHTS_CONNECTION_STRING Application Insights bağlantı dizesi kullanmaya da geçmeniz gerekir.

// requirements.txt
...
opencensus-extension-azure-functions
opencensus-ext-requests

import json
import logging

import requests
from opencensus.extension.azure.functions import OpenCensusExtension
from opencensus.trace import config_integration

config_integration.trace_integrations(['requests'])

OpenCensusExtension.configure()

def main(req, context):
    logging.info('Executing HttpTrigger with OpenCensus extension')

    # You must use context.tracer to create spans
    with context.tracer.span("parent"):
        response = requests.get(url='http://example.com')

    return json.dumps({
        'method': req.method,
        'response': response.status_code,
        'ctx_func_name': context.function_name,
        'ctx_func_dir': context.function_directory,
        'ctx_invocation_id': context.invocation_id,
        'ctx_trace_context_Traceparent': context.trace_context.Traceparent,
        'ctx_trace_context_Tracestate': context.trace_context.Tracestate,
        'ctx_retry_context_RetryCount': context.retry_context.retry_count,
        'ctx_retry_context_MaxRetryCount': context.retry_context.max_retry_count,
    })

HTTP tetikleyicisi

HTTP tetikleyicisi function.json dosyasında tanımlanır. name bağlamasının işlevindeki adlandırılmış parametreyle eşleşmesi gerekir. Önceki örneklerde bağlama adı req kullanılmıştır. Bu parametre bir HttpRequest nesnesidir ve bir HttpResponse nesnesi döndürülür.

HttpRequest nesnesinden istek üst bilgilerini, sorgu parametrelerini, yol parametrelerini ve ileti gövdesini alabilirsiniz.

Aşağıdaki örnek Python için HTTP tetikleyici şablonundan alınılmıştır.

def main(req: func.HttpRequest) -> func.HttpResponse:
    headers = {"my-http-header": "some-value"}

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!", headers=headers)
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             headers=headers, status_code=400
        )

Bu işlevde sorgu parametresinin name değerini HttpRequest nesnesinin parametresinden params alırsınız. yöntemini kullanarak JSON ile kodlanmış ileti gövdesini get_json okursunuz.

Benzer şekilde, döndürülen HttpResponse nesnesinde yanıt iletisi için ve headers değerini ayarlayabilirsinizstatus_code.

HTTP tetikleyicisi, httpRequest nesnesi olan adlandırılmış bağlama parametresini alan ve bir HttpResponse nesnesi döndüren bir yöntem olarak tanımlanır. function_name İşlev adını tanımlamak için yöntemine dekoratör uygularken, HTTP uç noktası dekoratör uygulanarak route ayarlanır.

Bu örnek Python v2 programlama modelinin HTTP tetikleyici şablonundan alınmıştı ve burada bağlama parametresi adı şeklindedir req. bu, Azure İşlevleri Core Tools veya Visual Studio Code kullanarak işlev oluşturduğunuzda sağlanan örnek koddır.

@app.function_name(name="HttpTrigger1")
@app.route(route="hello")
def test_function(req: func.HttpRequest) -> func.HttpResponse:
     logging.info('Python HTTP trigger function processed a request.')

     name = req.params.get('name')
     if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

     if name:
        return func.HttpResponse(f"Hello, {name}. This HTTP-triggered function executed successfully.")
     else:
        return func.HttpResponse(
             "This HTTP-triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

HttpRequest nesnesinden istek üst bilgilerini, sorgu parametrelerini, yol parametrelerini ve ileti gövdesini alabilirsiniz. Bu işlevde sorgu parametresinin name değerini HttpRequest nesnesinin parametresinden params alırsınız. yöntemini kullanarak JSON ile kodlanmış ileti gövdesini get_json okursunuz.

Benzer şekilde, döndürülen HttpResponse nesnesinde yanıt iletisi için ve headers değerini ayarlayabilirsinizstatus_code.

Bu örnekte bir ad geçirmek için, işlevi çalıştırırken sağlanan URL'yi yapıştırın ve ile ekleyin "?name={name}".

Web çerçeveleri

Http ile tetiklenen Python işlevlerinizle Flask ve FastAPI gibi Web Sunucusu Ağ Geçidi Arabirimi (WSGI) uyumlu ve Zaman Uyumsuz Sunucu Ağ Geçidi Arabirimi (ASGI) uyumlu çerçeveleri kullanabilirsiniz. Bu bölümde, işlevlerinizi bu çerçeveleri destekleyecek şekilde nasıl değiştireceğiniz gösterilmektedir.

İlk olarak, aşağıdaki örnekte gösterildiği gibi function.json dosyası HTTP tetikleyicisine eklenecek route şekilde güncelleştirilmelidir:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
       "authLevel": "anonymous",
       "type": "httpTrigger",
       "direction": "in",
       "name": "req",
       "methods": [
           "get",
           "post"
       ],
       "route": "{*route}"
    },
    {
       "type": "http",
       "direction": "out",
       "name": "$return"
    }
  ]
}

host.json dosyası, aşağıdaki örnekte gösterildiği gibi http routePrefixiçerecek şekilde de güncelleştirilmelidir:

{
  "version": "2.0",
  "logging": 
  {
    "applicationInsights": 
    {
      "samplingSettings": 
      {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": 
  {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  },
  "extensions": 
  {
    "http": 
    {
        "routePrefix": ""
    }
  }
}

Çerçeveniz tarafından kullanılan arabirime bağlı olarak Python kod dosyasını init.py güncelleştirin. Aşağıdaki örnekte Flask için ASGI işleyicisi yaklaşımı veya WSGI sarmalayıcı yaklaşımı gösterilmektedir:

app = fastapi.FastAPI()

@app.get("hello/{name}")
async def get_name(name: str):
  return {"name": name}

def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse:
    return func.AsgiMiddleware(app).handle(req, context)

HTTP ile tetiklenen Python işlevlerinizle Flask ve FastAPI gibi Zaman Uyumsuz Sunucu Ağ Geçidi Arabirimi (ASGI) uyumlu ve Web Sunucusu Ağ Geçidi Arabirimi (WSGI) uyumlu çerçeveler kullanabilirsiniz. Aşağıdaki örnekte gösterildiği gibi, önce host.json dosyasını http routePrefixiçerecek şekilde güncelleştirmeniz gerekir:

{
  "version": "2.0",
  "logging": 
  {
    "applicationInsights": 
    {
      "samplingSettings": 
      {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": 
  {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[2.*, 3.0.0)"
  },
  "extensions": 
  {
    "http": 
    {
        "routePrefix": ""
    }
  }
}

Çerçeve kodu aşağıdaki örneğe benzer:

AsgiFunctionApp ASGI HTTP işlevlerini oluşturmak için en üst düzey işlev uygulaması sınıfıdır.

# function_app.py

import azure.functions as func 
from fastapi import FastAPI, Request, Response 

fast_app = FastAPI() 

@fast_app.get("/return_http_no_body") 
async def return_http_no_body(): 
    return Response(content="", media_type="text/plain") 

app = func.AsgiFunctionApp(app=fast_app, 
                           http_auth_level=func.AuthLevel.ANONYMOUS)

Ölçeklendirme ve performans

Python işlev uygulamalarına yönelik ölçeklendirme ve performans için en iyi yöntemler için Python ölçeklendirme ve performans makalesine bakın.

Bağlam

Çalışırken bir işlevin çağrı bağlamını almak için bağımsız değişkeni imzasına context ekleyin.

Örneğin:

import azure.functions


def main(req: azure.functions.HttpRequest,
         context: azure.functions.Context) -> str:
    return f'{context.invocation_id}'

sınıfı Context aşağıdaki dize özniteliklerine sahiptir:

Öznitelik Açıklama
function_directory İşlevin çalıştığı dizin.
function_name İşlevin adı.
invocation_id Geçerli işlev çağrısının kimliği.
thread_local_storage İşlevin iş parçacığı yerel depolama alanı. Oluşturulan iş parçacıklarından günlüğe kaydetmeye yönelik yerel invocation_id bir öğe içerir.
trace_context Dağıtılmış izleme bağlamı. Daha fazla bilgi için bkz. Trace Context.
retry_context İşleve yeniden deneme bağlamı. Daha fazla bilgi için bkz. retry-policies.

Genel değişkenler

Uygulamanızın durumunun gelecekteki yürütmeler için korunacağı garanti değildir. Ancak Azure İşlevleri çalışma zamanı genellikle aynı uygulamanın birden çok yürütmesi için aynı işlemi yeniden kullanır. Pahalı bir hesaplamanın sonuçlarını önbelleğe almak için bunu genel değişken olarak bildirin.

CACHED_DATA = None


def main(req):
    global CACHED_DATA
    if CACHED_DATA is None:
        CACHED_DATA = load_json()

    # ... use CACHED_DATA in code

Ortam değişkenleri

Azure İşlevleri,hizmet bağlantı dizesi gibi uygulama ayarları çalışırken ortam değişkenleri olarak kullanıma sunulur. Kodunuzda bu ayarlara erişmenin iki ana yolu vardır.

Metot Açıklama
os.environ["myAppSetting"] Uygulama ayarını anahtar adına göre almaya çalışır ve başarısız olduğunda bir hata oluşturur.
os.getenv("myAppSetting") Uygulama ayarını anahtar adına göre almaya çalışır ve başarısız olduğunda döndürür null .

Bu yolların her ikisi de bildirmenizi import osgerektirir.

Aşağıdaki örnek, adlı myAppSettinganahtarla uygulama ayarını almak için kullanıros.environ["myAppSetting"]:

import logging
import os

import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
  # Get the setting named 'myAppSetting'
  my_app_setting_value = os.environ["myAppSetting"]
  logging.info(f'My app setting value:{my_app_setting_value}')

Yerel geliştirme için uygulama ayarları local.settings.json dosyasında tutulur.

Azure İşlevleri,hizmet bağlantı dizesi gibi uygulama ayarları çalışırken ortam değişkenleri olarak kullanıma sunulur. Kodunuzda bu ayarlara erişmenin iki ana yolu vardır.

Metot Açıklama
os.environ["myAppSetting"] Uygulama ayarını anahtar adına göre almaya çalışır ve başarısız olduğunda bir hata oluşturur.
os.getenv("myAppSetting") Uygulama ayarını anahtar adına göre almaya çalışır ve başarısız olduğunda döndürür null .

Bu yolların her ikisi de bildirmenizi import osgerektirir.

Aşağıdaki örnek, adlı myAppSettinganahtarla uygulama ayarını almak için kullanıros.environ["myAppSetting"]:

import logging
import os

import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="req")
def main(req: func.HttpRequest) -> func.HttpResponse:
  # Get the setting named 'myAppSetting'
  my_app_setting_value = os.environ["myAppSetting"]
  logging.info(f'My app setting value:{my_app_setting_value}')

Yerel geliştirme için uygulama ayarları local.settings.json dosyasında tutulur.

Python sürümü

Azure İşlevleri aşağıdaki Python sürümlerini destekler:

İşlevler sürümü Python* sürümleri
4.x 3.11
3,10
3.9
3.8
3.7
3.x 3.9
3.8
3.7

* Resmi Python dağıtımları

Azure'da işlev uygulamanızı oluştururken belirli bir Python sürümü istemek için komutunun az functionapp create seçeneğini kullanın--runtime-version. İşlevler çalışma zamanı sürümü seçeneğine --functions-version göre ayarlanır. Python sürümü, işlev uygulaması oluşturulduğunda ayarlanır ve Tüketim planında çalışan uygulamalar için değiştirilemez.

Çalışma zamanı, yerel olarak çalıştırdığınızda kullanılabilir Python sürümünü kullanır.

Python sürümünü değiştirme

Python işlev uygulamasını belirli bir dil sürümüne ayarlamak için, site yapılandırmasındaki alanda dili ve dilin LinuxFxVersion sürümünü belirtmeniz gerekir. Örneğin, Python uygulamasını Python 3.8 kullanacak şekilde değiştirmek için olarak python|3.8ayarlayınlinuxFxVersion.

Site ayarını görüntülemeyi ve değiştirmeyi linuxFxVersion öğrenmek için bkz. Azure İşlevleri çalışma zamanı sürümlerini hedefleme.

Daha fazla genel bilgi için Azure İşlevleri Azure İşlevleri çalışma zamanı destek ilkesine ve Desteklenen dillere bakın.

Paket yönetimi

Core Tools veya Visual Studio Code kullanarak yerel olarak geliştirme yaparken, gerekli paketlerin adlarını ve sürümlerini requirements.txt dosyasına ekleyin ve kullanarak yükleyin pip.

Örneğin, paketi PyPI'dan yüklemek requests için aşağıdaki requirements.txt dosyasını ve pip komutunu kullanabilirsiniz.

requests==2.19.1

pip install -r requirements.txt

İşlevlerinizi bir App Service planında çalıştırırken, requirements.txt içinde tanımladığınız bağımlılıklara gibi loggingyerleşik Python modüllerine göre öncelik verilir. Bu öncelik, yerleşik modüller kodunuzdaki dizinlerle aynı adlara sahip olduğunda çakışmalara neden olabilir. Tüketim planında veya Elastik Premium planında çalışırken bağımlılıklarınız varsayılan olarak önceliklendirilmediğinden çakışma olasılığı daha düşüktür.

App Service planında çalışan sorunları önlemek için, dizinlerinizi python yerel modülleriyle aynı şekilde adlandırmayın ve projenizin requirements.txt dosyasına Python yerel kitaplıkları eklemeyin.

Azure’da yayımlama

Yayımlamaya hazır olduğunuzda, herkese açık tüm bağımlılıklarınızın requirements.txt dosyasında listelendiğinden emin olun. Bu dosyayı proje dizininizin kökünde bulabilirsiniz.

Sanal ortam klasörü de dahil olmak üzere yayımlamanın dışında tutulan proje dosyalarını ve klasörlerini projenizin kök dizininde bulabilirsiniz.

Python projenizi Azure'da yayımlamak için desteklenen üç derleme eylemi vardır: uzaktan derleme, yerel derleme ve özel bağımlılıkları kullanan derlemeler.

Bağımlılıklarınızı oluşturmak ve sürekli teslim (CD) kullanarak yayımlamak için Azure Pipelines'ı da kullanabilirsiniz. Daha fazla bilgi edinmek için bkz . Azure Pipelines ile sürekli teslim.

Uzaktan derleme

Uzak derleme kullandığınızda, sunucuda geri yüklenen bağımlılıklar ve yerel bağımlılıklar üretim ortamıyla eşleşilir. Bu, karşıya yüklenecek daha küçük bir dağıtım paketine neden olur. Windows'da Python uygulamaları geliştirirken uzaktan derlemeyi kullanın. Projenizde özel bağımlılıklar varsa, ek dizin URL'si ile uzak derlemeyi kullanabilirsiniz.

Bağımlılıklar, requirements.txt dosyasının içeriğine göre uzaktan elde edilir. Uzak derleme , önerilen derleme yöntemidir. Varsayılan olarak, Python projenizi Azure'da yayımlamak için aşağıdaki func azure functionapp publish komutu kullandığınızda Core Tools uzak derleme isteğinde bulunur.

func azure functionapp publish <APP_NAME>

değerini Azure'daki işlev uygulamanızın adıyla değiştirmeyi <APP_NAME> unutmayın.

Visual Studio Code için Azure İşlevleri Uzantısı da varsayılan olarak uzak derleme isteğinde bulunur.

Yerel derleme

Bağımlılıklar, requirements.txt dosyasının içeriğine göre yerel olarak elde edilir. Yerel bir derlemeyle yayımlamak için aşağıdaki func azure functionapp publish komutu kullanarak uzak derleme yapmayı engelleyebilirsiniz:

func azure functionapp publish <APP_NAME> --build local

değerini Azure'daki işlev uygulamanızın adıyla değiştirmeyi <APP_NAME> unutmayın.

seçeneğini kullandığınızda--build local, proje bağımlılıkları requirements.txt dosyasından okunur ve bu bağımlı paketler yerel olarak indirilir ve yüklenir. Proje dosyaları ve bağımlılıkları yerel bilgisayarınızdan Azure'a dağıtılır. Bu, Azure'a daha büyük bir dağıtım paketi yüklenmesine neden olur. Bazı nedenlerden dolayı Core Tools kullanarak requirements.txt dosyasını alamıyorsanız yayımlama için özel bağımlılıklar seçeneğini kullanmanız gerekir.

Windows'da yerel olarak geliştirme yaparken yerel derlemeleri kullanmanızı önermeyiz.

Özel bağımlılıklar

Projenizin Python Paket Dizini'nde bulunmayan bağımlılıkları olduğunda, projeyi derlemenin iki yolu vardır. İlk yöntem olan derleme yöntemi, projeyi nasıl derlediğinize bağlıdır.

Ek dizin URL'si ile uzaktan derleme

Paketleriniz erişilebilir bir özel paket dizininden kullanılabiliyorsa, uzak bir derleme kullanın. Yayımlamadan önce adlı PIP_EXTRA_INDEX_URLbir uygulama ayarı oluşturduğunuzdan emin olun. Bu ayarın değeri, özel paket dizininizin URL'sidir. Bu ayarın kullanılması, uzak derlemeye seçeneğini kullanarak --extra-index-url çalışmasını pip install bildirir. Daha fazla bilgi edinmek için Python pip install belgelerine bakın.

Ek paket dizini URL'lerinizle temel kimlik doğrulama kimlik bilgilerini de kullanabilirsiniz. Daha fazla bilgi edinmek için Python belgelerindeki Temel kimlik doğrulaması kimlik bilgileri bölümüne bakın.

Yerel paketleri yükleme

Projeniz araçlarımızda genel kullanıma açık olmayan paketler kullanıyorsa, bunları __app__/.python_packages dizinine koyarak uygulamanızın kullanımına sunabilirsiniz. Yayımlamadan önce aşağıdaki komutu çalıştırarak bağımlılıkları yerel olarak yükleyin:

pip install  --target="<PROJECT_DIR>/.python_packages/lib/site-packages"  -r requirements.txt

Özel bağımlılıkları kullanırken, bağımlılıkları proje klasörüne zaten yüklemiş olduğunuz için yayımlama seçeneğini kullanmanız --no-build gerekir.

func azure functionapp publish <APP_NAME> --no-build

değerini Azure'daki işlev uygulamanızın adıyla değiştirmeyi <APP_NAME> unutmayın.

Birim testi

Python'da yazılan işlevler, standart test çerçeveleri kullanılarak diğer Python kodları gibi test edilebilir. Çoğu bağlamada, paketten azure.functions uygun bir sınıfın örneğini oluşturarak bir sahte giriş nesnesi oluşturmak mümkündür. azure.functions Paket hemen kullanılamadığından, yukarıdaki paket yönetimi bölümünde açıklandığı gibi requirements.txt dosyanız aracılığıyla yüklediğinizden emin olun.

Örnek olarak my_second_function, HTTP ile tetiklenen bir işlevin sahte testi aşağıda verilmiştir:

İlk olarak bir <project_root>/my_second_function/function.json dosyası oluşturun ve ardından bu işlevi HTTP tetikleyicisi olarak tanımlayın.

{
  "scriptFile": "__init__.py",
  "entryPoint": "main",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

Ardından ve shared_code.my_second_helper_functionuygulayabilirsinizmy_second_function.

# <project_root>/my_second_function/__init__.py
import azure.functions as func
import logging

# Use absolute import to resolve shared_code modules
from shared_code import my_second_helper_function

# Define an HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
def main(req: func.HttpRequest) -> func.HttpResponse:
  logging.info('Executing my_second_function.')

  initial_value: int = int(req.params.get('value'))
  doubled_value: int = my_second_helper_function.double(initial_value)

  return func.HttpResponse(
    body=f"{initial_value} * 2 = {doubled_value}",
    status_code=200
    )

# <project_root>/shared_code/__init__.py
# Empty __init__.py file marks shared_code folder as a Python package

# <project_root>/shared_code/my_second_helper_function.py

def double(value: int) -> int:
  return value * 2

HTTP tetikleyiciniz için test çalışmaları yazmaya başlayabilirsiniz.

# <project_root>/tests/test_my_second_function.py
import unittest

import azure.functions as func
from my_second_function import main

class TestFunction(unittest.TestCase):
  def test_my_second_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_second_function',
                           params={'value': '21'})
    # Call the function.
    resp = main(req)

    # Check the output.
    self.assertEqual(resp.get_body(), b'21 * 2 = 42',)

Python sanal ortamı klasörünüzde .venv , gibi pip install pytestsık kullandığınız Python test çerçevesini yükleyin. Ardından test sonucunu denetlemek için komutunu çalıştırın pytest tests .

İlk olarak, project_root/function_app.py dosyasını oluşturun <ve işlevini HTTP tetikleyicisi ve shared_code.my_second_helper_functionolarak uygulayınmy_second_function.>

# <project_root>/function_app.py
import azure.functions as func
import logging

# Use absolute import to resolve shared_code modules
from shared_code import my_second_helper_function

app = func.FunctionApp()

# Define the HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
@app.function_name(name="my_second_function")
@app.route(route="hello")
def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Executing my_second_function.')

    initial_value: int = int(req.params.get('value'))
    doubled_value: int = my_second_helper_function.double(initial_value)

    return func.HttpResponse(
        body=f"{initial_value} * 2 = {doubled_value}",
        status_code=200
    )

# <project_root>/shared_code/__init__.py
# Empty __init__.py file marks shared_code folder as a Python package

# <project_root>/shared_code/my_second_helper_function.py

def double(value: int) -> int:
  return value * 2

HTTP tetikleyiciniz için test çalışmaları yazmaya başlayabilirsiniz.

# <project_root>/tests/test_my_second_function.py
import unittest
import azure.functions as func

from function_app import main

class TestFunction(unittest.TestCase):
  def test_my_second_function(self):
    # Construct a mock HTTP request.
    req = func.HttpRequest(method='GET',
                           body=None,
                           url='/api/my_second_function',
                           params={'value': '21'})
    # Call the function.
    func_call = main.build().get_user_function()
    resp = func_call(req)
    # Check the output.
    self.assertEqual(
        resp.get_body(),
        b'21 * 2 = 42',
    )

.venv Python sanal ortam klasörünüzün içine, gibi pip install pytestsık kullandığınız Python test çerçevesini yükleyin. Ardından test sonucunu denetlemek için komutunu çalıştırın pytest tests .

Geçici dosyalar

tempfile.gettempdir() yöntemi, Linux'ta /tmp olan geçici bir klasör döndürür. Uygulamanız, işlevleriniz tarafından çalıştırılırken oluşturulan ve kullanılan geçici dosyaları depolamak için bu dizini kullanabilir.

Önemli

Geçici dizine yazılan dosyaların çağrılar arasında kalıcı olması garanti değildir. Ölçeği genişletme sırasında geçici dosyalar örnekler arasında paylaşılamaz.

Aşağıdaki örnek, geçici dizinde (/tmp) adlandırılmış bir geçici dosya oluşturur:

import logging
import azure.functions as func
import tempfile

from os import listdir

#---
   tempFilePath = tempfile.gettempdir()
   fp = tempfile.NamedTemporaryFile()
   fp.write(b'Hello world!')
   filesDirListInTemp = listdir(tempFilePath)

Testlerinizi proje klasöründen ayrı bir klasörde tutmanızı öneririz. Bu eylem, test kodunu uygulamanızla dağıtmanızı engeller.

Önceden yüklenmiş kitaplıklar

Python işlevleri çalışma zamanıyla birlikte birkaç kitaplık gelir.

Python standart kitaplığı

Python standart kitaplığı, her Python dağıtımıyla birlikte gönderilen yerleşik Python modüllerinin listesini içerir. Bu kitaplıkların çoğu, dosya girişi/çıkışı (G/Ç) gibi sistem işlevlerine erişmenize yardımcı olur. Windows sistemlerinde bu kitaplıklar Python ile birlikte yüklenir. Unix tabanlı sistemlerde bunlar paket koleksiyonları tarafından sağlanır.

Python sürümünüzün kitaplığını görüntülemek için şuraya gidin:

Python çalışan bağımlılıklarını Azure İşlevleri

Azure İşlevleri Python çalışanı belirli bir kitaplık kümesi gerektirir. Bu kitaplıkları işlevlerinizde de kullanabilirsiniz, ancak Bunlar Python standardının bir parçası değildir. İşlevleriniz bu kitaplıklardan herhangi birini kullanıyorsa, bunlar Azure İşlevleri dışında çalışırken kodunuz tarafından kullanılamayabilir.

Not

İşlev uygulamanızın requirements.txt dosyası bir azure-functions-worker girdi içeriyorsa, kaldırın. İşlev çalışanı Azure İşlevleri platformu tarafından otomatik olarak yönetilir ve bunu düzenli olarak yeni özellikler ve hata düzeltmeleriyle güncelleştiririz. requirements.txt dosyasına eski bir çalışan sürümünü el ile yüklemek beklenmeyen sorunlara neden olabilir.

Not

Paketiniz çalışanın bağımlılıklarıyla (örneğin protobuf, tensorflow veya grpcio) çakıştırabilecek bazı kitaplıklar içeriyorsa, uygulamanızın çalışan bağımlılıklarına başvurmasını önlemek için uygulama ayarlarında olarak yapılandırın PYTHON_ISOLATE_WORKER_DEPENDENCIES 1 .

Azure İşlevleri Python kitaplığı

Her Python çalışan güncelleştirmesi, Azure İşlevleri Python kitaplığının (azure.functions) yeni bir sürümünü içerir. Bu yaklaşım, her güncelleştirme geriye dönük olarak uyumlu olduğundan Python işlev uygulamalarınızı sürekli olarak güncelleştirmenizi kolaylaştırır. Bu kitaplığın yayınlarının listesi için azure-functions PyPi'ye gidin.

Çalışma zamanı kitaplığı sürümü Azure tarafından düzeltilir ve requirements.txt tarafından geçersiz kılınamaz. requirements.txt girdisi azure-functions yalnızca lint ve müşteri farkındalığı içindir.

Çalışma zamanınızdaki Python işlevleri kitaplığının gerçek sürümünü izlemek için aşağıdaki kodu kullanın:

getattr(azure.functions, '__version__', '< 1.2.1')

Çalışma zamanı sistem kitaplıkları

Python çalışanı Docker görüntülerinde önceden yüklenmiş sistem kitaplıklarının listesi için aşağıdakilere bakın:

İşlevler çalışma zamanı Debian sürümü Python sürümleri
Sürüm 3.x Buster Python 3.7
Python 3.8
Python 3.9

Python çalışan uzantıları

Azure İşlevleri'de çalışan Python çalışan işlemi, üçüncü taraf kitaplıklarını işlev uygulamanızla tümleştirmenize olanak tanır. Bu uzantı kitaplıkları, işlevinizin yürütülmesinin yaşam döngüsü boyunca belirli işlemleri ekleyebilecek ara yazılım işlevi görür.

Uzantılar işlev kodunuzda standart python kitaplığı modülüne çok benzer şekilde içeri aktarılır. Uzantılar aşağıdaki kapsamlara göre çalıştırılır:

Scope Açıklama
Uygulama düzeyi Herhangi bir işlev tetikleyicisine içeri aktarıldığında, uzantı uygulamadaki her işlev yürütmesi için geçerlidir.
İşlev düzeyi Yürütme yalnızca içeri aktarıldığı belirli işlev tetikleyicisi ile sınırlıdır.

Uzantının çalıştırıldığı kapsam hakkında daha fazla bilgi edinmek için her uzantının bilgilerini gözden geçirin.

Uzantılar bir Python çalışan uzantısı arabirimi uygular. Bu eylem, python çalışan işleminin işlevin yürütme yaşam döngüsü sırasında uzantı koduna çağrı yapmasını sağlar. Daha fazla bilgi edinmek için bkz . Uzantı oluşturma.

Uzantıları kullanma

Aşağıdakileri yaparak Python işlevlerinizde bir Python çalışan uzantısı kitaplığı kullanabilirsiniz:

  1. Uzantı paketini projenizin requirements.txt dosyasına ekleyin.
  2. Kitaplığı uygulamanıza yükleyin.
  3. Aşağıdaki uygulama ayarlarını ekleyin:
    • Yerel olarak: local.settings.json dosyanızın bölümüne girin."PYTHON_ENABLE_WORKER_EXTENSIONS": "1" Values
    • Azure: Uygulama ayarlarınıza girinPYTHON_ENABLE_WORKER_EXTENSIONS=1.
  4. Uzantı modülünü işlev tetikleyicinize aktarın.
  5. Gerekirse uzantı örneğini yapılandırın. Yapılandırma gereksinimleri uzantının belgelerinde vurgulanmalıdır.

Önemli

Üçüncü taraf Python çalışan uzantısı kitaplıkları Microsoft tarafından desteklenmez veya garanti edilir. İşlev uygulamanızda kullandığınız tüm uzantıların güvenilir olduğundan ve kötü amaçlı veya kötü yazılmış bir uzantı kullanma riskinin tam olduğundan emin olmanız gerekir.

Üçüncü taraflar, işlev uygulamanızda uzantılarını yükleme ve kullanma hakkında belirli belgeler sağlamalıdır. Uzantının nasıl kullanılacağını gösteren temel bir örnek için bkz . Uzantınızı kullanma.

Kapsam gereği bir işlev uygulamasında uzantıları kullanma örnekleri aşağıda verilmiştir:

# <project_root>/requirements.txt
application-level-extension==1.0.0

# <project_root>/Trigger/__init__.py

from application_level_extension import AppExtension
AppExtension.configure(key=value)

def main(req, context):
  # Use context.app_ext_attributes here

Uzantı oluşturma

Uzantılar, Azure İşlevleri tümleştirilebilen işlevler oluşturan üçüncü taraf kitaplık geliştiricileri tarafından oluşturulur. Uzantı geliştiricisi, özellikle işlev yürütme bağlamında çalıştırılacak şekilde tasarlanmış özel mantık içeren Python paketlerini tasarlar, uygular ve yayınlar. Bu uzantılar PyPI kayıt defterinde veya GitHub depolarında yayımlanabilir.

Python çalışan uzantısı paketi oluşturmayı, paketlemeyi, yayımlamayı ve kullanmayı öğrenmek için bkz. Azure İşlevleri için Python çalışan uzantıları geliştirme.

Uygulama düzeyi uzantılar

Bir uygulama kapsamında çalıştırıldığından devralınan AppExtensionBase bir uzantı.

AppExtensionBase uygulamanız için aşağıdaki soyut sınıf yöntemlerini kullanıma sunar:

Metot Açıklama
init Uzantı içeri aktarıldıktan sonra çağrılır.
configure Uzantıyı yapılandırmak için gerektiğinde işlev kodundan çağrılır.
post_function_load_app_level İşlev yüklendikten hemen sonra çağrılır. İşlev adı ve işlev dizini uzantıya geçirilir. İşlev dizininin salt okunur olduğunu ve bu dizindeki yerel bir dosyaya yazma girişiminin başarısız olduğunu unutmayın.
pre_invocation_app_level İşlev tetiklenmeden hemen önce çağrılır. İşlev bağlamı ve işlev çağırma bağımsız değişkenleri uzantıya geçirilir. Genellikle işlev kodunun tüketebileceği bağlam nesnesindeki diğer öznitelikleri geçirebilirsiniz.
post_invocation_app_level İşlev yürütmesi tamamlandıktan hemen sonra çağrılır. İşlev bağlamı, işlev çağırma bağımsız değişkenleri ve çağırma dönüş nesnesi uzantıya geçirilir. Bu uygulama, yaşam döngüsü kancalarının yürütülmesinin başarılı olup olmadığını doğrulamak için iyi bir yerdir.

İşlev düzeyi uzantıları

FuncExtensionBase'den devralan bir uzantı belirli bir işlev tetikleyicisinde çalışır.

FuncExtensionBase uygulamalar için aşağıdaki soyut sınıf yöntemlerini kullanıma sunar:

Metot Açıklama
__init__ Uzantının oluşturucus. Belirli bir işlevde bir uzantı örneği başlatıldığında çağrılır. Bu soyut yöntemi uygularken, uygun uzantı kaydı için bir filename parametreyi kabul etmek ve üst öğesinin yöntemine super().__init__(filename) geçirmek isteyebilirsiniz.
post_function_load İşlev yüklendikten hemen sonra çağrılır. İşlev adı ve işlev dizini uzantıya geçirilir. İşlev dizininin salt okunur olduğunu ve bu dizindeki yerel bir dosyaya yazma girişiminin başarısız olduğunu unutmayın.
pre_invocation İşlev tetiklenmeden hemen önce çağrılır. İşlev bağlamı ve işlev çağırma bağımsız değişkenleri uzantıya geçirilir. Genellikle işlev kodunun tüketebileceği bağlam nesnesindeki diğer öznitelikleri geçirebilirsiniz.
post_invocation İşlev yürütmesi tamamlandıktan hemen sonra çağrılır. İşlev bağlamı, işlev çağırma bağımsız değişkenleri ve çağırma dönüş nesnesi uzantıya geçirilir. Bu uygulama, yaşam döngüsü kancalarının yürütülmesinin başarılı olup olmadığını doğrulamak için iyi bir yerdir.

Çıkış noktaları arası kaynak paylaşma

Azure İşlevleri çıkış noktaları arası kaynak paylaşımını (CORS) destekler. CORS, portalda ve Azure CLI aracılığıyla yapılandırılır. CORS izin verilen çıkış noktaları listesi, işlev uygulaması düzeyinde geçerlidir. CORS etkinleştirildiğinde yanıtlar üst bilgiyi içerir Access-Control-Allow-Origin . Daha fazla bilgi için bkz. Çıkış noktaları arası kaynak paylaşma.

Çıkış noktaları arası kaynak paylaşımı (CORS), Python işlev uygulamaları için tam olarak desteklenir.

Zaman Uyumsuz

Varsayılan olarak, Python için bir konak örneği aynı anda yalnızca bir işlev çağrısını işleyebilir. Bunun nedeni Python'ın tek iş parçacıklı bir çalışma zamanı olmasıdır. Çok sayıda G/Ç olayını işleyen veya G/Ç'ye bağlı olan bir işlev uygulaması için, işlevleri zaman uyumsuz olarak çalıştırarak performansı önemli ölçüde geliştirebilirsiniz. Daha fazla bilgi için bkz. Azure İşlevleri'da Python uygulamalarının tüm performansını geliştirme.

Paylaşılan bellek (önizleme)

aktarım hızını geliştirmek için Azure İşlevleri işlem dışı Python dil çalışanınızın İşlevler ana bilgisayar işlemiyle bellek paylaşmasına olanak tanır. İşlev uygulamanız performans sorunlarına neden olduğunda, değerine 1sahip FUNCTIONS_WORKER_SHARED_MEMORY_DATA_TRANSFER_ENABLED adlı bir uygulama ayarı ekleyerek paylaşılan belleği etkinleştirebilirsiniz. Paylaşılan bellek etkinleştirildiğinde, paylaşılan belleği 256 MB'a eşdeğer olan gibi 268435456bir değere ayarlamak için DOCKER_SHM_SIZE ayarını kullanabilirsiniz.

Örneğin, 1 MB'tan büyük yükleri aktarmak için Blob Depolama bağlamalarını kullanırken performans sorunlarını azaltmak için paylaşılan belleği etkinleştirebilirsiniz.

Bu işlev yalnızca Premium ve Ayrılmış (Azure Uygulaması Hizmet) planlarında çalışan işlev uygulamaları için kullanılabilir. Daha fazla bilgi edinmek için bkz . Paylaşılan bellek.

Bilinen sorunlar ve SSS

Yaygın sorunlar için iki sorun giderme kılavuzu aşağıdadır:

v2 programlama modeliyle ilgili bilinen sorunlar için iki sorun giderme kılavuzu aşağıdadır:

Bilinen tüm sorunlar ve özellik istekleri GitHub sorunları listesinde izlenir. Bir sorunla karşılaşırsanız ve sorunu GitHub'da bulamazsanız yeni bir sorun açın ve sorunun ayrıntılı açıklamasını ekleyin.

Sonraki adımlar

Daha fazla bilgi edinmek için aşağıdaki kaynaklara bakın:

Python kullanırken sorun mu yaşıyorsunuz? Bize neler olduğunu anlat.