Panduan Azure Functions untuk pengembang Python

Artikel
06/29/2022
23 menit untuk membaca

Artikel ini berisi pengantar untuk mengembangkan Azure Functions menggunakan Python. Artikel ini menganggap Anda sudah membaca panduan pengembang Azure Functions.

Sebagai pengembang Python, Anda mungkin juga tertarik dengan salah satu artikel berikut:

Memulai	Konsep	Skenario/Sampel
Fungsi Python menggunakan Visual Studio Code Fungsi Python dengan terminal/perintah	Panduan pengembang Opsi hosting Pertimbangan performa	Klasifikasi gambar dengan PyTorch Contoh Azure Automation Pembelajaran mesin dengan TensorFlow Telusuri sampel Python

Catatan

Meskipun Anda dapat mengembangkan fungsi berbasis Python secara lokal di Windows, fungsi Python didukung di Azure hanya saat berjalan di Linux. Lihat daftar kombinasi sistem operasi/runtime yang didukung.

Model pemrograman

Azure Functions mengharapkan fungsi menjadi metode stateless dalam skrip Python Anda yang memproses input dan menghasilkan output. Secara default, runtime mengharapkan metode yang diimplementasikan sebagai metode global yang disebut main() di file _init_.py. Anda juga dapat menentukan titik entri alternatif.

Data dari pemicu dan pengikatan terikat ke fungsi melalui atribut metode yang menggunakan properti name yang ditentukan dalam file function.json. Misalnya, function.json di bawah ini menjelaskan fungsi sederhana yang dipicu oleh permintaan HTTP bernama req:

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

Berdasarkan definisi ini, file _init_.py yang berisi kode fungsi mungkin terlihat seperti contoh berikut:

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

Anda juga dapat secara eksplisit mendeklarasikan tipe atribut dan menampilkan jenis dalam fungsi menggunakan anotasi jenis Python. Tindakan ini membantu Anda menggunakan fitur IntelliSense dan autocomplete yang disediakan oleh banyak editor kode Python.

import azure.functions


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

Gunakan anotasi Python yang disertakan dalam paket azure.functions.* untuk mengikat input dan output ke metode Anda.

Titik masuk alternatif

Anda dapat mengubah perilaku default fungsi secara opsional dengan menentukan properti scriptFile dan entryPoint di file function.json. Misalnya, file function.json di bawah ini memberi tahu runtime untuk menggunakan metode customentry() dalam file main.py sebagai titik masuk untuk fungsi Anda:

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

Struktur folder

Struktur folder yang direkomendasikan untuk proyek Azure Functions dalam Python terlihat seperti contoh berikut:

 <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

Folder proyek utama (<project_root>) dapat berisi file berikut:

local.settings.json: Untuk menyimpan pengaturan aplikasi dan string koneksi yang digunakan saat fungsi berjalan secara lokal. File ini tidak dipublikasikan ke Azure. Untuk mempelajari lebih lanjut, lihat File pengaturan lokal.
requirements.txt: Berisi daftar paket Python yang diinstal sistem saat menerbitkan ke Azure.
host.json: Berisi opsi konfigurasi yang memengaruhi semua fungsi dalam instans aplikasi fungsi. File ini dipublikasikan ke Azure. Tidak semua opsi didukung saat fungsi berjalan secara lokal. Untuk mempelajari lebih lanjut, lihat referensi host.json.
.vscode/: (Opsional) Berisi konfigurasi Visual Studio Code yang disimpan. Untuk mempelajari lebih lanjut, lihat Pengaturan Pengguna dan Ruang Kerja.
.venv/: (Opsional) Berisi lingkungan virtual Python yang digunakan untuk pengembangan lokal.
Dockerfile: (Opsional) Digunakan saat memublikasikan proyek Anda dalam kontainer kustom.
tests/ : (Opsional) Berisi kasus pengujian aplikasi fungsi Anda.
.funcignore: (Opsional) Mendeklarasikan file yang seharusnya tidak dipublikasikan ke Azure. Biasanya, file ini berisi .vscode/ untuk mengabaikan pengaturan editor Anda, .venv/ untuk mengabaikan lingkungan virtual Python lokal, tests/ untuk mengabaikan kasus pengujian, dan local.settings.json untuk mencegah publikasi pengaturan aplikasi lokal.

Setiap fungsi memiliki file kode dan file konfigurasi pengikatan (function.json) sendiri.

Saat Anda menyebarkan proyek ke aplikasi fungsi di Azure, seluruh konten folder (<project_root>) proyek utama harus disertakan dalam paket, tetapi bukan folder itu sendiri. Itu berarti host.json harus berada di akar paket. Kami menyarankan agar pengujian Anda disimpan di dalam folder bersama dengan fungsi lain. Dalam contoh ini, folder tersebut adalah tests/. Untuk informasi selengkapnya, lihat Pengujian Unit.

Mengimpor perilaku

Anda dapat mengimpor modul dalam kode fungsi menggunakan referensi absolut dan relatif. Berdasarkan struktur folder yang ditunjukkan di atas, impor berikut bekerja dari dalam file fungsi <project_root>\my_first_function\__init__.py:

from shared_code import my_first_helper_function #(absolute)

import shared_code.my_second_helper_function #(absolute)

from . import example #(relative)

Catatan

Folder shared_code/ harus memiliki file __init__.py untuk menandainya sebagai paket Python saat menggunakan sintaks impor absolut.

Impor __app__ berikut dan selain impor relatif tingkat atas tidak digunakan lagi. Pemeriksa jenis statis dan kerangka kerja pengujian Python tidak mendukungnya.

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)

Pemicu dan Input

Input dibagi menjadi dua kategori di Azure Functions: input pemicu dan input pengikatan lainnya. Meskipun mereka berbeda di dalam file function.json, keduanya memiliki penggunaan yang sama dalam kode Python. Ketika fungsi berjalan secara lokal, string koneksi atau rahasia yang diperlukan oleh sumber pemicu dan input dipertahankan dalam koleksi Values dari file local.settings.json. Saat fungsi berjalan di Azure, string koneksi atau rahasia yang sama disimpan dengan aman sebagai pengaturan aplikasi.

Misalnya, kode berikut menunjukkan perbedaan antara keduanya:

// 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": "AzureWebJobsStorage"
    }
  ]
}

// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "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()}')

Ketika fungsi dipanggil, permintaan HTTP diteruskan ke fungsi sebagai req. Entri akan diambil dari Azure Blob Storage berdasarkan ID di URL rute dan disediakan sebagai obj dalam isi fungsi. Di sini, akun penyimpanan yang ditentukan adalah string koneksi yang ditemukan dalam pengaturan aplikasi AzureWebJobsStorage, yang merupakan akun penyimpanan yang sama dengan yang digunakan oleh aplikasi fungsi.

Output

Output dapat dinyatakan dalam parameter output dan nilai yang ditampilkan. Jika hanya ada satu output, sebaiknya gunakan nilai yang dikembalikan. Bila ada beberapa output, Anda harus menggunakan parameter output.

Untuk menggunakan nilai yang ditampilkan dari suatu fungsi sebagai nilai dari pengikatan output, properti name dari pengikatan harus diatur ke $return dalam function.json.

Untuk menghasilkan beberapa output, gunakan metode set() yang disediakan oleh antarmuka azure.functions.Out guna menetapkan nilai ke pengikatan. Misalnya, fungsi berikut dapat mendorong pesan ke antrean dan juga menampilkan respons HTTP:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "msg",
      "direction": "out",
      "type": "queue",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    },
    {
      "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

Pencatatan

Akses ke pencatat runtime Azure Functions tersedia melalui penangan root logging di aplikasi fungsi Anda. Pencatat ini terikat pada Application Insights dan memungkinkan Anda menandai peringatan dan kesalahan yang terjadi selama eksekusi fungsi.

Contoh berikut mencatat pesan info saat fungsi dipanggil melalui pemicu HTTP:

import logging


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

Tersedia lebih banyak metode pencatatan yang memungkinkan Anda menulis ke konsol pada tingkat pelacakan yang berbeda:

Metode	Deskripsi
`critical(_message_)`	Menulis pesan dengan tingkat KRITIS pada pencatat akar.
`error(_message_)`	Menulis pesan dengan level ERROR pada pencatat akar.
`warning(_message_)`	Menulis pesan dengan tingkat PERINGATAN pada pencatat akar.
`info(_message_)`	Menulis pesan dengan tingkat INFO pada pencatat akar.
`debug(_message_)`	Menulis pesan dengan tingkat DEBUG pada pencatat akar.

Untuk mempelajari selengkapnya tentang pengelogan, lihat Memantau Azure Functions.

Log telemetri kustom

Secara default, runtime Azure Functions mengumpulkan log dan data telemetri lainnya yang dihasilkan oleh fungsi Anda. Telemetri ini berakhir sebagai jejak di Application Insights. Secara default, pemicu dan pengikatan juga mengumpulkan telemetri permintaan dan dependensi untuk layanan Azure tertentu.

Untuk mengumpulkan telemetri dependensi kustom dan permintaan kustom di luar pengikatan, Anda dapat menggunakan Ekstensi Python OpenCensus. Ekstensi Azure Functions mengirimkan data telemetri kustom ke instans Application Insights Anda. Anda dapat menemukan daftar ekstensi yang didukung di repositori OpenCensus.

Catatan

Untuk menggunakan ekstensi OpenCensus Python, Anda harus mengaktifkan ekstensi pekerja Python di aplikasi fungsi Anda dengan mengatur PYTHON_ENABLE_WORKER_EXTENSIONS ke 1. Anda juga perlu beralih menggunakan string koneksi Application Insights dengan menambahkan pengaturan APPLICATIONINSIGHTS_CONNECTION_STRING ke pengaturan aplikasi Anda, jika belum ada.

// 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,
    })

Pemicu dan pengikatan HTTP

Pemicu HTTP didefinisikan dalam file function.json. Parameter name dari pengikatan harus cocok dengan parameter bernama di dalam fungsi.

Contoh sebelumnya menggunakan nama pengikatan req. Parameter ini adalah objek HttpRequest, dan objek HttpResponse dikembalikan.

Dari objek HttpRequest, Anda bisa mendapatkan header permintaan, parameter kueri, parameter rute, dan isi pesan.

Contoh berikut berasal dari templat pemicu HTTP untuk Python:

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
        )

Dalam fungsi ini, nilai nameparameter kueri diperoleh dari params parameter objek HttpRequest. Isi pesan yang dikodekan JSON dibaca menggunakan metode get_json.

Anda juga dapat mengatur informasi status_code dan headers untuk pesan respons di objek HttpResponse yang ditampilkan.

Kerangka kerja web

Anda dapat menggunakan kerangka kerja yang kompatibel dengan WSGI dan ASGI seperti Flask dan FastAPI dengan fungsi Python yang dipicu HTTP Anda. Bagian ini menunjukkan cara memodifikasi fungsi Anda agar mendukung kerangka kerja ini.

Pertama, file function.json harus diperbarui untuk menyertakan route dalam pemicu HTTP, seperti yang ditunjukkan dalam contoh berikut:

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

File host.json juga harus diperbarui untuk menyertakan routePrefix HTTP, seperti yang ditunjukkan dalam contoh berikut:

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

Perbarui file kode Python init.py berdasarkan antarmuka yang digunakan kerangka kerja Anda. Contoh berikut menunjukkan pendekatan handler ASGI atau pendekatan wrapper WSGI untuk Flask:

ASGI
WSGI

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 AsgiMiddleware(app).handle(req, context)

app=Flask("Test")

@app.route("hello/<name>", methods=['GET'])
def hello(name: str):
    return f"hello {name}"

def main(req: func.HttpRequest, context) -> func.HttpResponse:
  logging.info('Python HTTP trigger function processed a request.')
  return func.WsgiMiddleware(app).handle(req, context)

Untuk contoh selengkapnya, lihat Menggunakan kerangka kerja Flask dengan Azure Functions.

Penskalaan dan performa

Untuk praktik terbaik performa dan penskalaan untuk aplikasi fungsi Python, lihat Meningkatkan performa throughput aplikasi Python di Azure Functions.

Konteks

Untuk mendapatkan konteks pemanggilan fungsi selama eksekusi, sertakan argumen context di dalam tanda tangannya.

Contohnya:

import azure.functions


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

Kelas Konteks memiliki atribut string berikut:

function_directory: Direktori tempat fungsi berjalan.
function_name: Nama fungsi.
invocation_id: ID pemanggilan fungsi saat ini.
trace_context: Konteks untuk pelacakan terdistribusi. Untuk informasi selengkapnya, lihat Konteks Pelacakan di situs web W3C.
retry_context: Konteks untuk percobaan ulang ke fungsi. Untuk informasi selengkapnya, lihat Kebijakan coba lagi.

Variabel global

Tidak ada jaminan status aplikasi Anda akan dipertahankan untuk eksekusi di masa mendatang. Namun, runtime Azure Functions sering menggunakan kembali proses yang sama untuk beberapa eksekusi aplikasi yang sama. Untuk menyimpan (cache) hasil komputasi yang mahal, nyatakan hasil tersebut sebagai variabel global:

CACHED_DATA = None


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

    # ... use CACHED_DATA in code

Variabel lingkungan

Di Azure Functions, pengaturan aplikasi, seperti string koneksi layanan, diekspos sebagai variabel lingkungan selama eksekusi. Ada dua cara utama untuk mengakses pengaturan ini dalam kode Anda:

Metode	Deskripsi
`os.environ["myAppSetting"]`	Coba mendapatkan pengaturan aplikasi menggunakan nama kunci. Ia memberikan kesalahan saat tidak berhasil.
`os.getenv("myAppSetting")`	Coba mendapatkan pengaturan aplikasi menggunakan nama kunci. Ia menampilkan `null` saat tidak berhasil.

Kedua cara ini mengharuskan Anda untuk menyatakanimport os.

Contoh berikut os.environ["myAppSetting"] mendapatkan pengaturan aplikasi, dengan kunci bernama 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}')

Untuk pengembangan lokal, pengaturan aplikasi dipertahankan dalam file local.settings.json.

Versi Python

Azure Functions mendukung versi Python berikut. Berikut adalah distribusi Python resmi.

Versi fungsi	Versi Python
4.x	3.9 3.8 3.7
3.x	3.9 3.8 3.7 3.6+
2.x	3.7 3.6+

Untuk meminta versi Python tertentu saat Anda membuat aplikasi fungsi di Azure, gunakan opsi --runtime-version dari perintah az functionapp create. Opsi --functions-version mengatur versi runtime Azure Functions. Versi Python diatur saat aplikasi fungsi dibuat dan tidak dapat diubah.

Runtime menggunakan versi Python yang tersedia, ketika Anda menjalankannya secara lokalan.

Mengubah versi Python

Untuk mengatur aplikasi fungsi Python ke versi bahasa tertentu, Anda perlu menentukan bahasa serta versi bahasa tersebut di bidang linuxFxVersion dalam konfigurasi situs. Misalnya, untuk mengubah aplikasi Python untuk menggunakan Python 3.8, atur linuxFxVersion ke python|3.8.

Untuk mempelajari selengkapnya tentang kebijakan dukungan runtime Azure Functions, lihat Kebijakan dukungan runtime bahasa.

Untuk melihat daftar lengkap versi Python yang didukung untuk aplikasi fungsi, lihat Bahasa yang didukung di Azure Functions.

Azure CLI

Anda dapat menampilkan dan mengatur linuxFxVersion dari Azure CLI menggunakan perintah az functionapp config show. Ganti <function_app> dengan nama aplikasi fungsi Anda. Ganti <my_resource_group> dengan nama grup sumber daya untuk aplikasi fungsi Anda.

az functionapp config show --name <function_app> \
--resource-group <my_resource_group>

Anda melihat linuxFxVersion pada output berikut, yang telah dipotong demi kejelasan:

{
  ...
  "kind": null,
  "limits": null,
  "linuxFxVersion": <LINUX_FX_VERSION>,
  "loadBalancing": "LeastRequests",
  "localMySqlEnabled": false,
  "location": "West US",
  "logsDirectorySizeLimit": 35,
   ...
}

Anda dapat memperbarui pengaturan linuxFxVersion di aplikasi fungsi menggunakan perintah az functionapp config set. Dalam kode berikut:

Ganti <FUNCTION_APP> dengan nama aplikasi fungsi Anda.
Ganti <RESOURCE_GROUP> dengan nama grup sumber daya untuk aplikasi fungsi Anda.
Ganti <LINUX_FX_VERSION> dengan versi Python yang Anda ingin gunakan, yang diawali dengan python|. Contoh: python|3.9.

az functionapp config set --name <FUNCTION_APP> \
--resource-group <RESOURCE_GROUP> \
--linux-fx-version <LINUX_FX_VERSION>

Anda dapat menjalankan perintah ini dari Azure Cloud Shell dengan memilih Coba di sampel kode sebelumnya. Anda juga dapat menggunakan Azure CLI secara lokal untuk menjalankan perintah tersebut setelah menggunakan login az untuk masuk.

Aplikasi fungsi dihidupkan ulang setelah Anda merubah konfigurasi situs.

Manajemen paket

Saat mengembangkan secara lokal menggunakan Azure Functions Core Tools atau Visual Studio Code, tambahkan nama dan versi paket yang diperlukan ke file requirements.txt dan instal menggunakan pip.

Misalnya, Anda dapat menggunakan file persyaratan dan perintah pip berikut untuk menginstal paket requests dari PyPI:

requests==2.19.1

pip install -r requirements.txt

Menerbitkan ke Azure

Saat Anda siap untuk menerbitkan, pastikan semua dependensi yang tersedia untuk umum telah tercantum dalam file requirements.txt. File ini berada di akar direktori proyek Anda.

Anda juga dapat menemukan file dan folder proyek yang dikecualikan dari penerbitan, termasuk folder lingkungan virtual, di direktori akar proyek Anda.

Ada tiga tindakan build yang didukung untuk memublikasikan proyek Python Anda ke Azure: build jarak jauh, build lokal, dan build yang menggunakan dependensi kustom.

Anda juga dapat menggunakan Azure Pipelines untuk membangun dependensi dan memublikasikan menggunakan pengiriman berkelanjutan (CD). Untuk mempelajari selengkapnya, lihat Pengiriman berkelanjutan menggunakan Azure DevOps.

Build jarak jauh

Ketika menggunakan build jarak jauh, dependensi yang dipulihkan di server dan dependensi native harus sesuai dengan lingkungan produksi. Build ini menghasilkan paket penyebaran yang lebih kecil untuk diunggah. Gunakan build jarak jauh saat mengembangkan aplikasi Python di Windows. Jika proyek Anda memiliki dependensi kustom, Anda dapat menggunakan build jarak jauh dengan URL indeks tambahan.

Dependensi diperoleh secara jarak jauh berdasarkan konten file requirements.txt. Build jarak jauh adalah metode build yang direkomendasikan. Secara default, Azure Functions Core Tools meminta build jarak jauh saat Anda menggunakan perintah func azure functionapp publish berikut untuk memublikasikan proyek Python Anda ke Azure. Ganti <APP_NAME> dengan nama aplikasi fungsi Anda.

func azure functionapp publish <APP_NAME>

Ekstensi Azure Functions untuk Visual Studio Code juga meminta build jarak jauh secara default.

Build lokal

Dependensi diperoleh secara lokal berdasarkan konten file requirements.txt. Build jarak jauh dapat dicegah menggunakan perintah func azure functionapp publish berikut untuk memublikasikan dengan build lokal. Ganti <APP_NAME> dengan nama aplikasi fungsi Anda.

func azure functionapp publish <APP_NAME> --build local

Saat Anda menggunakan opsi --build local, dependensi proyek dibaca dari file requirements.txt. Paket dependen tersebut diunduh dan diinstal secara lokal. File dan dependensi proyek disebarkan dari komputer lokal Anda ke Azure. Hal ini mengakibatkan paket penyebaran yang lebih besar yang diunggah ke Azure. Jika Anda tidak bisa mendapatkan file requirements.txt menggunakan Core Tools, gunakan opsi dependensi kustom untuk publikasi.

Penggunaan build lokal saat mengembangkan secara lokal di Windows tidak disarankan.

Dependensi kustom

Ketika proyek Anda memiliki dependensi yang tidak ditemukan di Indeks Paket Python, ada dua cara untuk membangun proyek.

Build jarak jauh dengan URL indeks tambahan

Ketika paket Anda tersedia dari indeks paket kustom yang dapat diakses, gunakan build jarak jauh. Sebelum memublikasikan, pastikan untuk membuat setelan aplikasi bernama PIP_EXTRA_INDEX_URL. Nilai untuk pengaturan ini adalah URL indeks paket kustom Anda. Menggunakan pengaturan ini berarti memerintahkan build jarak jauh untuk menjalankan pip install menggunakan opsi --extra-index-url. Untuk mempelajari lebih lanjut, lihat dokumentasi penginstalan Python pip.

Anda juga dapat menggunakan kredensial autentikasi dasar dengan URL indeks paket tambahan Anda. Untuk mempelajari selengkapnya, lihat Kredensial autentikasi dasar dalam dokumentasi Python.

Menginstal paket lokal

Jika proyek Anda menggunakan paket yang tidak tersedia secara publik, Anda dapat membuatnya tersedia untuk aplikasi Anda dengan meletakkannya dalam direktori __app__/.python_packages. Sebelum memublikasikan, jalankan perintah berikut untuk menginstal dependensi secara lokal:

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

Saat menggunakan dependensi kustom, Anda harus menggunakan opsi publikasi --no-build karena Anda telah menginstal dependensi ke dalam folder proyek. Ganti <APP_NAME> dengan nama aplikasi fungsi Anda.

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

Pengujian Unit

Anda dapat menguji fungsi yang ditulis dalam Python dengan cara yang sama seperti Anda menguji kode Python lainnya: melalui kerangka kerja pengujian standar. Untuk sebagian besar pengikatan, Anda dapat membuat objek input mock dengan membuat instans kelas yang sesuai dari paket azure.functions. Karena paket azure.functions tidak langsung tersedia, pastikan untuk menginstalnya melalui file requirements.txt Anda seperti yang dijelaskan di bagian manajemen paket sebelumnya.

Ambil my_second_function sebagai contoh. Berikut adalah pengujian mock dari fungsi yang dipicu HTTP.

Pertama, untuk membuat file <project_root>/my_second_function/function.json dan mendefinisikan fungsi ini sebagai pemicu HTTP, gunakan kode berikut:

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

Sekarang, Anda dapat mengimplementasikan my_second_function dan shared_code.my_second_helper_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

Anda dapat mulai menulis kasus pengujian untuk pemicu HTTP Anda:

# <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',
        )

Di dalam lingkungan virtual Python .venv Anda, instal kerangka kerja pengujian Python favorit Anda, misalnya pip install pytest. Jalankan pytest tests untuk memeriksa hasil pengujian.

File sementara

Metode tempfile.gettempdir() menampilkan folder sementara, yang mana di Linux adalah /tmp. Aplikasi Anda bisa menggunakan direktori ini untuk menyimpan file sementara yang dihasilkan dan digunakan oleh fungsi Anda selama eksekusi.

Penting

File yang ditulis ke direktori sementara tidak dijamin akan bertahan di seluruh pemanggilan. Selama peluasan skala, file sementara tidak dibagikan antar instans.

Contoh berikut membuat file sementara bernama di direktori sementara (/tmp):

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)

Kami menyarankan agar Anda mempertahankan pengujian di folder yang terpisah dari folder proyek. Tindakan ini mencegah Anda menyebarkan kode pengujian dengan aplikasi Anda.

Pustaka yang sebelumnya terinstal

Beberapa pustaka dilengkapi dengan runtime untuk Azure Functions di Python.

Pustaka Python Standar

Pustaka Standar Python berisi daftar modul Python bawaan yang dikirim dengan setiap distribusi Python. Sebagian besar pustaka ini akan membantu Anda mengakses fungsi sistem, seperti file I/O. Pada sistem Windows, pustaka ini terinstal dengan Python. Pada sistem Unix, koleksi paket menyediakannya.

Untuk menampilkan detail lengkap daftar pustaka ini, gunakan tautan di bawah:

Dependensi pekerja

Pekerja Python untuk Azure Functions memerlukan sekumpulan pustaka tertentu. Anda juga dapat menggunakan pustaka ini di fungsi Anda, tetapi bukan merupakan bagian dari standar Python. Jika fungsi Anda bergantung pada salah satu pustaka ini, fungsi tersebut mungkin tidak tersedia untuk kode Anda saat berjalan di luar Azure Functions. Anda dapat menemukan daftar dependensi terperinci di bagian install\_requires dalam file setup.py.

Catatan

Jika requirements.txt aplikasi fungsi Anda mengandung entri azure-functions-worker, hapus entri tersebut. Platform Azure Functions dikelola secara otomatis oleh pekerja ini dan kami memperbaruinya secara rutin dengan fitur baru dan perbaikan bug. Menginstal pekerja versi lama secara manual di requirements.txt bisa menyebabkan masalah yang tidak terduga.

Catatan

Jika paket Anda berisi pustaka tertentu yang mungkin bertabrakan dengan dependensi pekerja (misalnya protobuf, tensorflow, grpcio), konfigurasikan PYTHON_ISOLATE_WORKER_DEPENDENCIES ke 1 di pengaturan aplikasi untuk mencegah aplikasi Anda merujuk pada dependensi pekerja. Fitur ini masih dalam tahap pratinjau.

Pustaka Python Azure Functions

Setiap pembaruan pekerja Python menyertakan versi baru pustaka Python Azure Functions (azure.functions). Pendekatan ini memudahkan pembaruan yang berkelanjutan terhadap aplikasi fungsi Python Anda, karena setiap pembaruan selalu kompatibel dengan versi sebelumnya. Anda dapat menemukan daftar rilis pustaka ini di informasi azure-functions di situs web PyPi.

Versi pustaka runtime diperbaiki oleh Azure dan tidak dapat ditimpa oleh requirements.txt. Entri azure-functions di requirements.txt hanya untuk linting dan kesadaran pelanggan.

Gunakan kode berikut untuk melacak versi dari pustaka Python Azure Functions di runtime Anda:

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

Pustaka sistem runtime

Tabel berikut ini mencantumkan pustaka sistem yang telah diinstal sebelumnya di gambar Docker untuk pekerja Python:

Waktu proses fungsi	Versi Debian	Versi Python
Versi 2.x	Stretch	Python 3.6 Python 3.7
Versi 3.x	Buster	Python 3.6 Python 3.7 Python 3.8 Python 3.9

Ekstensi pekerja Python

Proses pekerja Python yang berjalan di Azure Functions memungkinkan Anda mengintegrasikan pustaka pihak ketiga ke dalam aplikasi fungsi Anda. Pustaka ekstensi ini bertindak sebagai middleware yang dapat menginjeksi operasi tertentu selama siklus hidup eksekusi fungsi Anda.

Ekstensi diimpor dalam kode fungsi Anda seperti modul pustaka Python standar. Ekstensi dijalankan berdasarkan cakupan berikut:

Lingkup	Deskripsi
Tingkat aplikasi	Saat ekstensi diimpor ke pemicu fungsi apa pun, ekstensi berlaku untuk setiap eksekusi fungsi di aplikasi.
Tingkat fungsi	Eksekusi hanya terbatas pada pemicu fungsi tertentu tempat diimpor.

Tinjau informasi untuk ekstensi tertentu guna mempelajari lebih lanjut tentang cakupan tempat ekstensi berjalan.

Ekstensi mengimplementasikan antarmuka ekstensi pekerja Python. Tindakan ini memungkinkan proses pekerja Python memanggil kode ekstensi selama siklus hidup eksekusi fungsi.

Menggunakan ekstensi

Anda dapat menggunakan pustaka ekstensi pekerja Python di fungsi Python dengan mengikuti langkah dasar ini:

Tambahkan paket ekstensi dalam file requirements.txt untuk proyek Anda.
Instal pustaka ke aplikasi Anda.
Tambahkan pengaturan aplikasi PYTHON_ENABLE_WORKER_EXTENSIONS:
- Untuk menambahkan pengaturan secara lokal, tambahkan "PYTHON_ENABLE_WORKER_EXTENSIONS": "1" di bagian Values dari file local.settings.json Anda.
- Untuk menambahkan pengaturan di Azure, tambahkan PYTHON_ENABLE_WORKER_EXTENSIONS=1 ke pengaturan aplikasi Anda.
Impor modul ekstensi ke pemicu fungsi Anda.
Konfigurasikan instans ekstensi, jika diperlukan. Persyaratan konfigurasi harus dipanggil dalam dokumentasi ekstensi.

Penting

Microsoft tidak mendukung atau menjamin pustaka ekstensi pekerja Python pihak ketiga. Pastikan bahwa ekstensi apa pun yang Anda gunakan di aplikasi fungsi Anda dapat dipercaya. Anda bertanggung jawab penuh atas penggunaan ekstensi yang ditulis dengan tidak baik.

Pihak ketiga harus memberikan dokumentasi khusus tentang cara menginstal dan menggunakan ekstensi tertentu di aplikasi fungsi Anda. Untuk contoh dasar cara menggunakan ekstensi, lihat Menggunakan ekstensi Anda.

Berikut adalah contoh penggunaan ekstensi di aplikasi fungsi, menurut cakupan:

Tingkat aplikasi
Tingkat fungsi

# <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

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


# <project_root>/Trigger/__init__.py

from function_level_extension import FuncExtension
func_ext_instance = FuncExtension(__file__)

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

Membuat ekstensi

Ekstensi dibuat oleh pengembang pustaka pihak ketiga yang telah membuat fungsionalitas yang dapat diintegrasikan ke dalam Azure Functions. Pengembang ekstensi mendesain, menerapkan, dan merilis paket Python yang berisi logika kustom yang dirancang khusus untuk dijalankan dalam konteks eksekusi fungsi. Ekstensi ini dapat diterbitkan baik ke registri PyPI atau repositori GitHub.

Untuk mempelajari cara membuat, mengemas, menerbitkan, dan menggunakan paket ekstensi pekerja Python, lihat Mengembangkan ekstensi pekerja Python untuk Azure Functions.

Ekstensi tingkat aplikasi

Ekstensi yang diwarisi dari AppExtensionBase berjalan dalam cakupan aplikasi.

AppExtensionBase mengekspos metode kelas abstrak berikut untuk Anda terapkan:

Metode	Deskripsi
`init`	Dipanggil setelah ekstensi diimpor.
`configure`	Dipanggil dari kode fungsi saat diperlukan untuk mengonfigurasi ekstensi.
`post_function_load_app_level`	Dipanggil tepat setelah fungsi dimuat. Nama fungsi dan direktori fungsi diteruskan ke ekstensi. Jangan lupa bahwa direktori fungsi bersifat baca-saja. Setiap upaya untuk menulis ke file lokal dalam direktori ini gagal.
`pre_invocation_app_level`	Dipanggil tepat sebelum fungsi dipicu. Konteks fungsi dan argumen pemanggilan fungsi diteruskan ke ekstensi. Anda biasanya dapat meneruskan atribut lain dalam objek konteks untuk digunakan oleh kode fungsi.
`post_invocation_app_level`	Dipanggil tepat setelah eksekusi fungsi selesai. Konteks fungsi, argumen pemanggilan fungsi, dan objek pengembalian pemanggilan diteruskan ke ekstensi. Penerapan ini adalah tempat yang baik untuk memvalidasi apakah eksekusi kait siklus hidup berhasil.

Ekstensi tingkat aplikasi

Ekstensi yang mewarisi dari FuncExtensionBase berjalan dalam pemicu fungsi tertentu.

FuncExtensionBase mengekspos metode kelas abstrak berikut untuk penerapan:

Metode	Deskripsi
`__init__`	Dipanggil saat instans ekstensi diinisialisasi dalam fungsi tertentu. Metode ini adalah konstruktor ekstensi. Saat menerapkan metode abstrak ini, Anda mungkin ingin menerima parameter `filename` dan meneruskannya ke metode `super().__init__(filename)` induk untuk pendaftaran ekstensi yang tepat.
`post_function_load`	Dipanggil tepat setelah fungsi dimuat. Nama fungsi dan direktori fungsi diteruskan ke ekstensi. Jangan lupa bahwa direktori fungsi bersifat baca-saja. Setiap upaya untuk menulis ke file lokal dalam direktori ini gagal.
`pre_invocation`	Dipanggil tepat sebelum fungsi dipicu. Konteks fungsi dan argumen pemanggilan fungsi diteruskan ke ekstensi. Anda biasanya dapat meneruskan atribut lain dalam objek konteks untuk digunakan oleh kode fungsi.
`post_invocation`	Dipanggil tepat setelah eksekusi fungsi selesai. Konteks fungsi, argumen pemanggilan fungsi, dan objek pengembalian pemanggilan diteruskan ke ekstensi. Penerapan ini adalah tempat yang baik untuk memvalidasi apakah eksekusi kait siklus hidup berhasil.

Azure Functions mendukung berbagi sumber daya lintas asal (CORS). CORS dikonfigurasi di portal dan melalui Azure CLI. Daftar asal yang diizinkan CORS berlaku di tingkat aplikasi fungsi. Dengan mengaktifkan CORS, respons menyertakan header Access-Control-Allow-Origin. Untuk mengetahui informasi selengkapnya, lihat Berbagi sumber daya lintas asal.

CORS sepenuhnya didukung untuk aplikasi fungsi Python.

Asinkron

Secara default, sebuah instans host untuk Python hanya dapat memproses satu permintaan fungsi pada satu waktu. Ini karena Python adalah runtime berutas tunggal. Untuk aplikasi yang memproses sejumlah besar peristiwa I/O dan/atau terikat I/O, Anda dapat melakukan peningkatan performa secara signifikan dengan menjalankan fungsi secara asinkron. Untuk informasi lebih lanjut, lihat Meningkatkan performa throughput dari aplikasi Python di Azure Functions.

Memori bersama (pratinjau)

Untuk meningkatkan throughput, Azure Functions memungkinkan pekerja bahasa Python Anda yang tidak diproses berbagi memori dengan proses host. Saat aplikasi fungsi Anda mengalami penyempitan, Anda dapat mengaktifkan memori bersama dengan menambahkan pengaturan aplikasi bernama FUNCTIONS_WORKER_SHARED_MEMORY_DATA_TRANSFER_ENABLED dengan nilai 1. Dengan memori bersama diaktifkan, Anda kemudian dapat menggunakan pengaturan DOCKER_SHM_SIZE untuk mengatur memori bersama ke sesuatu seperti 268435456, yang setara dengan 256 MB.

Misalnya, Anda dapat mengaktifkan memori bersama untuk mengurangi penyempitan saat menggunakan pengikatan Azure Blob Storage guna mentransfer payload yang lebih besar dari 1 MB.

Fungsionalitas ini hanya tersedia untuk aplikasi fungsi yang berjalan dalam paket Premium dan Khusus (Azure App Service). Untuk mempelajari selengkapnya, lihat Memori bersama.

FAQ dan masalah umum

Berikut ini adalah daftar panduan pemecahan masalah untuk masalah umum:

Semua masalah dan permintaan fitur yang diketahui dilacak menggunakan daftar masalah GitHub. Jika Anda mengalami masalah dan tidak dapat menemukan masalah di GitHub, buka masalah baru dan sertakan deskripsi terperinci tentang masalah tersebut.

Langkah berikutnya

Untuk informasi selengkapnya, lihat sumber berikut ini:

Memiliki masalah? Beri tahu kami.

Panduan Azure Functions untuk pengembang Python

Model pemrograman

Titik masuk alternatif

Struktur folder

Mengimpor perilaku

Pemicu dan Input

Output

Pencatatan

Log telemetri kustom

Pemicu dan pengikatan HTTP

Kerangka kerja web

Penskalaan dan performa

Konteks

Variabel global

Variabel lingkungan

Versi Python

Mengubah versi Python

Manajemen paket

Menerbitkan ke Azure

Build jarak jauh

Build lokal

Dependensi kustom

Build jarak jauh dengan URL indeks tambahan

Menginstal paket lokal

Pengujian Unit

File sementara

Pustaka yang sebelumnya terinstal

Pustaka Python Standar

Dependensi pekerja

Pustaka Python Azure Functions

Pustaka sistem runtime

Ekstensi pekerja Python

Menggunakan ekstensi

Membuat ekstensi

Ekstensi tingkat aplikasi

Ekstensi tingkat aplikasi

Berbagi sumber daya lintas asal (CORS)

Asinkron

Memori bersama (pratinjau)

FAQ dan masalah umum

Langkah berikutnya