Как интегрировать Azure OpenAI и Python: Полное руководство для разработчиков?

  •   
  •   77813
  •   17 мин
  •   20

В современном мире искусственный интеллект и большие языковые модели (LLM) стали неотъемлемой частью инновационных решений, трансформируя подходы к разработке программного обеспечения. Способность машин понимать, генерировать и обрабатывать естественный язык открывает беспрецедентные возможности для автоматизации, персонализации и создания совершенно новых пользовательских опытов. Azure OpenAI Service предоставляет разработчикам уникальную возможность интегрировать мощные модели OpenAI, такие как GPT-3.5-turbo и GPT-4o-mini, в свои приложения, используя надежную, безопасную и масштабируемую инфраструктуру Microsoft Azure. Это не просто доступ к передовым моделям, но и возможность их использования в корпоративной среде с соблюдением требований безопасности и соответствия.

Саммари статьи
ChatGPT ChatGPT
Google AI Google AI
Grok Grok
Perplexity Perplexity

Python, благодаря своей простоте, обширной экосистеме библиотек и доминирующему положению в области машинного обучения и искусственного интеллекта, является идеальным выбором для взаимодействия с Azure OpenAI. Это руководство призвано предоставить разработчикам полное, пошаговое понимание того, как эффективно интегрировать Azure OpenAI с Python.

Мы рассмотрим все этапы: от первоначальной настройки ресурсов Azure и подготовки среды Python до выполнения первых запросов, создания интерактивного веб-приложения на Flask и его развертывания в Azure App Service с использованием управляемых удостоверений. Вы также узнаете о лучших практиках и расширенных возможностях, которые помогут вам создавать надежные и производительные решения. Приготовьтесь погрузиться в мир интеллектуальной разработки и раскрыть весь потенциал Azure OpenAI с Python.

Настройка Среды и Ресурсов Azure OpenAI

Создание ресурса Azure OpenAI и развертывание модели

Для начала работы с Azure OpenAI необходимо создать соответствующий ресурс в вашей подписке Azure. Это можно сделать через портал Azure или с помощью Azure CLI. Рекомендуется использовать Azure CLI для автоматизации и воспроизводимости.

  1. Создайте группу ресурсов (если её нет):

az group create —name MyOpenAIResourceGroup —location eastus «`

  1. Создайте ресурс Azure OpenAI:

az cognitiveservices account create
—name MyOpenAIInstance
—resource-group MyOpenAIResourceGroup
—location eastus
—kind OpenAI
—sku S0 «`

  1. Разверните модель: После создания ресурса перейдите на портал Azure, найдите ваш ресурс Azure OpenAI и в разделе "Управление развертываниями" (Model deployments) разверните нужную модель, например, gpt-3.5-turbo или gpt-4o-mini. Присвойте ей имя развертывания, например, gpt35turbo. Это имя будет использоваться в вашем коде.

  2. Получите конечную точку и ключ API: Эти данные необходимы для аутентификации. Их можно найти в разделе "Ключи и конечная точка" (Keys and Endpoint) вашего ресурса Azure OpenAI на портале.

Подготовка Python-проекта: виртуальное окружение и зависимости

После настройки ресурсов Azure OpenAI, следующим шагом является подготовка локальной среды разработки Python.

  1. Создайте виртуальное окружение: Это изолирует зависимости вашего проекта.

python -m venv .venv «`

  1. Активируйте виртуальное окружение:

    • Windows: .\.venv\Scripts\activate

    • macOS/Linux: source ./.venv/bin/activate

  2. Установите необходимые пакеты:

pip install openai python-dotenv «` Пакет openai предоставляет SDK для взаимодействия с API, а python-dotenv поможет безопасно управлять переменными окружения, такими как ключи API.

  1. Создайте файл requirements.txt: Зафиксируйте зависимости для воспроизводимости.

pip freeze > requirements.txt «` Теперь ваша среда готова к написанию кода и взаимодействию с Azure OpenAI.

Создание ресурса Azure OpenAI и развертывание модели

Для начала работы с Azure OpenAI необходимо создать соответствующий ресурс в вашей подписке Azure и развернуть в нем желаемую модель. Этот процесс можно выполнить как через портал Azure, так и с помощью Azure CLI, что часто предпочтительнее для автоматизации и разработчиков.

1. Создание ресурса Azure OpenAI

Прежде всего, убедитесь, что у вас установлен и настроен Azure CLI. Если у вас еще нет группы ресурсов, создайте ее:

az group create --name my-openai-rg --location eastus

Затем создайте сам ресурс Azure OpenAI. Обратите внимание на kind (OpenAI) и sku (S0):

az cognitiveservices account create \
    --name my-openai-resource \
    --resource-group my-openai-rg \
    --location eastus \
    --kind OpenAI \
    --sku S0

После выполнения этой команды Azure создаст ресурс, который будет служить контейнером для ваших моделей.

2. Развертывание модели

После создания ресурса необходимо развернуть конкретную модель, например, gpt-35-turbo или gpt-4o-mini. Имя развертывания (deployment-name) будет использоваться в вашем коде для обращения к модели.

az cognitiveservices account deployment create \
    --name my-openai-resource \
    --resource-group my-openai-rg \
    --deployment-name gpt-35-turbo-deployment \
    --model-name gpt-35-turbo \
    --model-version "0125" \
    --model-format OpenAI

Вы можете выбрать любую доступную модель и соответствующую ей версию. Убедитесь, что выбранная модель доступна в вашем регионе.

3. Получение конечной точки и ключей API

Для взаимодействия с развернутой моделью вам понадобятся конечная точка (endpoint) и ключ API. Их можно найти в портале Azure, перейдя к созданному ресурсу Azure OpenAI и выбрав раздел "Keys and Endpoint" (Ключи и конечная точка). Скопируйте один из ключей и значение конечной точки. Эти данные будут использоваться для аутентификации ваших Python-приложений.

Подготовка Python-проекта: виртуальное окружение и зависимости

После того как ресурсы Azure OpenAI настроены, необходимо подготовить локальную среду разработки Python. Это критически важный шаг для обеспечения чистоты проекта, управления зависимостями и безопасного хранения конфиденциальных данных.

Создание виртуального окружения

Использование виртуального окружения (virtual environment) — это лучшая практика в разработке на Python. Оно позволяет изолировать зависимости вашего проекта от других проектов и глобальной установки Python, предотвращая конфликты версий. Для создания виртуального окружения выполните следующие команды в корневой папке вашего проекта:

  1. Создание окружения:

    python -m venv .venv

  2. Активация окружения:

    • Linux/macOS:

      source .venv/bin/activate

    • Windows (PowerShell):

      .venv\Scripts\Activate.ps1

    • Windows (Command Prompt):

      .venv\Scripts\activate.bat

После активации виртуального окружения в вашей командной строке появится префикс (.venv), указывающий на то, что вы работаете внутри него.

Установка необходимых зависимостей

Для взаимодействия с Azure OpenAI из Python нам потребуется официальная библиотека openai. Кроме того, для безопасного управления ключами API и конечными точками мы будем использовать библиотеку python-dotenv, которая позволяет загружать переменные окружения из файла .env.

Установите эти пакеты с помощью pip:

pip install openai python-dotenv

Настройка переменных окружения

Для безопасного хранения конфиденциальных данных, таких как ключи API и конечные точки, создайте файл с именем .env в корневой папке вашего проекта. Добавьте в него следующие строки, заменив заполнители на ваши данные, полученные на предыдущем шаге:

AZURE_OPENAI_ENDPOINT="https://ВАШ_РЕСУРС.openai.azure.com/"
AZURE_OPENAI_API_KEY="ВАШ_КЛЮЧ_API"
AZURE_OPENAI_API_VERSION="2026-02-01" # Используйте актуальную версию API

Важно: Никогда не коммитьте файл .env в систему контроля версий (например, Git). Добавьте его в .gitignore.

Основы Взаимодействия с Azure OpenAI через Python

Теперь, когда наша среда разработки настроена, а необходимые библиотеки установлены, мы готовы выполнить наш первый запрос к Azure OpenAI. Этот шаг продемонстрирует базовое взаимодействие с моделью завершения чата.

Выполнение первого запроса завершения чата

Для начала убедитесь, что переменные окружения (AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, AZURE_OPENAI_API_VERSION, AZURE_OPENAI_DEPLOYMENT_NAME) загружены. Мы будем использовать класс AzureOpenAI из библиотеки openai.

import os
from openai import AzureOpenAI
from dotenv import load_dotenv

# Загружаем переменные окружения из .env файла
load_dotenv()

# Инициализируем клиент Azure OpenAI
client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
)

deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME") # Например, 'gpt-35-turbo' или 'gpt-4o-mini'

# Выполняем запрос завершения чата
response = client.chat.completions.create(
    model=deployment_name,
    messages=[
        {"role": "system", "content": "Вы полезный ИИ-ассистент."},
        {"role": "user", "content": "Привет, как дела?"}
    ]
)

# Выводим ответ модели
print(response.choices[0].message.content)

В этом примере мы отправляем простой диалог, где role: system задает контекст для модели, а role: user содержит запрос пользователя. Модель GPT-3.5-turbo или GPT-4o-mini (в зависимости от вашего развертывания) обработает запрос и вернет ответ.

Методы аутентификации: ключи API и Microsoft Entra ID (Managed Identity)

В приведенном выше примере мы использовали ключ API для аутентификации. Это самый простой способ начать работу, но для производственных приложений, особенно развернутых в Azure, рекомендуется использовать управляемые удостоверения (Managed Identity) через Microsoft Entra ID.

  • Ключи API: Подходят для быстрой разработки и тестирования. Однако они требуют безопасного хранения и ротации, так как их утечка может привести к несанкционированному доступу.

  • Управляемые удостоверения (Managed Identity): Это функция Azure, которая позволяет вашим приложениям, работающим в Azure (например, в Azure App Service), аутентифицироваться в других службах Azure без необходимости управлять учетными данными. Azure автоматически управляет жизненным циклом удостоверения. Для использования управляемых удостоверений с AzureOpenAI клиент может быть инициализирован с помощью DefaultAzureCredential из библиотеки azure-identity:

    from azure.identity import DefaultAzureCredential
# ...
credential = DefaultAzureCredential()
client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    azure_ad_token_provider=credential.get_token,
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
)

    Этот подход значительно повышает безопасность, поскольку секреты не хранятся в коде или переменных окружения приложения.

Выполнение первого запроса завершения чата

После того как ваша среда Python настроена, а ресурс Azure OpenAI и модель развернуты, вы готовы выполнить свой первый запрос завершения чата. Этот шаг демонстрирует базовое взаимодействие с моделью, используя установленный ранее пакет openai и настроенные переменные окружения для аутентификации.

Для начала убедитесь, что у вас установлена библиотека openai (как было описано в предыдущем разделе) и что переменные окружения AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY и AZURE_OPENAI_API_VERSION корректно заданы. Затем используйте следующий код:

import os
from openai import AzureOpenAI

try:
    # Инициализация клиента AzureOpenAI с использованием переменных окружения
    client = AzureOpenAI(
        azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
        api_key=os.environ["AZURE_OPENAI_API_KEY"],
        api_version=os.environ["AZURE_OPENAI_API_VERSION"]
    )

    # Укажите имя вашего развертывания модели (например, 'gpt-35-turbo' или 'gpt-4o-mini')
    deployment_name = "gpt-35-turbo" # Замените на имя вашего развертывания в Azure OpenAI

    print(f"Отправка запроса к модели '{deployment_name}'...")

    # Выполнение запроса завершения чата
    response = client.chat.completions.create(
        model=deployment_name,
        messages=[
            {"role": "system", "content": "Вы полезный ИИ-ассистент, который отвечает кратко и по делу."},
            {"role": "user", "content": "Привет, как дела?"}
        ],
        max_tokens=100,
        temperature=0.7
    )

    print("Ответ получен:")
    print(response.choices[0].message.content)

except KeyError as e:
    print(f"Ошибка: Не установлена переменная окружения {e}. Убедитесь, что AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY и AZURE_OPENAI_API_VERSION установлены.")
except Exception as e:
    print(f"Произошла ошибка при выполнении запроса: {e}")

В этом примере:

  • AzureOpenAI клиент инициализируется с использованием конечной точки, ключа API и версии API, полученных из переменных окружения.

  • deployment_name — это имя, которое вы дали вашей развернутой модели в Azure OpenAI Studio.

  • Список messages содержит диалог. Каждый элемент — это словарь с role (например, system, user, assistant) и content.

  • max_tokens ограничивает длину генерируемого ответа, а temperature контролирует случайность ответов (от 0 до 2).

  • Ответ модели доступен через response.choices[0].message.content.

Этот базовый запрос является фундаментом для всех дальнейших взаимодействий с моделями Azure OpenAI.

Методы аутентификации: ключи API и Microsoft Entra ID (Managed Identity)

После того как мы успешно выполнили первый запрос, важно углубиться в методы аутентификации, которые обеспечивают безопасное взаимодействие вашего Python-приложения с Azure OpenAI. Существует два основных подхода: использование ключей API и управляемых удостоверений (Managed Identity) Microsoft Entra ID.

Ключи API

Ключи API — это традиционный и наиболее простой способ аутентификации. Каждый ресурс Azure OpenAI имеет два ключа API, которые можно найти в разделе «Ключи и конечная точка» (Keys and Endpoint) на портале Azure. Эти ключи представляют собой длинные секретные строки, которые предоставляют полный доступ к вашему ресурсу.

Для использования ключа API в Python, как мы уже видели, его необходимо передать клиенту AzureOpenAI:

from openai import AzureOpenAI
import os

client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    api_version="2026-02-01"
)

Важно: Никогда не храните ключи API непосредственно в коде. Всегда используйте переменные окружения, Azure Key Vault или другие безопасные методы хранения секретов. Регулярно меняйте ключи API для повышения безопасности.

Microsoft Entra ID (Managed Identity)

Для приложений, развернутых в Azure (например, в Azure App Service, Azure Functions, Azure Kubernetes Service), настоятельно рекомендуется использовать управляемые удостоверения Microsoft Entra ID. Этот метод устраняет необходимость в управлении секретами (ключами API), поскольку Azure автоматически управляет жизненным циклом учетных данных.

Управляемые удостоверения позволяют вашему приложению аутентифицироваться в Azure OpenAI, используя собственное удостоверение, предоставленное Azure. Для этого необходимо:

  1. Включить управляемое удостоверение для вашего ресурса Azure (например, App Service).

  2. Предоставить этому управляемому удостоверению роль «Пользователь служб когнитивных вычислений Azure OpenAI» (Cognitive Services OpenAI User) на вашем ресурсе Azure OpenAI.

В Python вы можете использовать библиотеку azure-identity для аутентификации с помощью DefaultAzureCredential:

from openai import AzureOpenAI
from azure.identity import DefaultAzureCredential
import os

credential = DefaultAzureCredential()

client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    azure_ad_token_provider=credential.get_token("https://cognitiveservices.azure.com/.default"),
    api_version="2026-02-01"
)

DefaultAzureCredential автоматически пытается аутентифицироваться, используя различные методы (переменные окружения, управляемые удостоверения, Azure CLI и т.д.), что делает его очень гибким для локальной разработки и развертывания в облаке. Этот подход значительно повышает безопасность, поскольку вам не нужно вручную управлять секретами.

Создание Интерактивного Приложения с Flask и Azure OpenAI

Теперь, когда мы освоили методы аутентификации, применим эти знания для создания интерактивного веб-приложения. Мы разработаем простой чат-бот на Flask, который будет использовать Azure OpenAI для генерации ответов, а затем создадим базовый веб-интерфейс для взаимодействия с ним.

Разработка простого чат-бота на Flask

Начнем с файла app.py, который будет содержать логику нашего Flask-приложения. Убедитесь, что переменные окружения для AZURE_OPENAI_ENDPOINT и AZURE_OPENAI_API_KEY (или соответствующие для Managed Identity) настроены, как обсуждалось ранее.

import os
from flask import Flask, request, jsonify, render_template
from openai import AzureOpenAI

app = Flask(__name__)

client = AzureOpenAI(
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key = os.getenv("AZURE_OPENAI_API_KEY"),
    api_version = "2026-02-01"
)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/chat', methods=['POST'])
def chat():
    user_message = request.json.get('message')
    if not user_message:
        return jsonify({'error': 'No message provided'}), 400

    try:
        response = client.chat.completions.create(
            model="gpt-35-turbo" if os.getenv("AZURE_OPENAI_MODEL_NAME") is None else os.getenv("AZURE_OPENAI_MODEL_NAME"), # Имя развернутой модели
            messages=[
                {"role": "system", "content": "Вы полезный ИИ-помощник."},
                {"role": "user", "content": user_message}
            ]
        )
        ai_response = response.choices[0].message.content
        return jsonify({'response': ai_response})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)

В этом коде мы инициализируем клиент AzureOpenAI, используя переменные окружения. Маршрут / отображает index.html, а /chat обрабатывает POST-запросы, отправляя сообщение пользователя в Azure OpenAI и возвращая ответ.

Реклама

Разработка веб-интерфейса (HTML) и тестирование локально

Создайте папку templates в корне вашего проекта и внутри нее файл index.html:

<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Чат-бот Azure OpenAI</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        #chat-box { border: 1px solid #ccc; padding: 10px; height: 300px; overflow-y: scroll; margin-bottom: 10px; }
        .message { margin-bottom: 5px; }
        .user { color: blue; }
        .ai { color: green; }
    </style>
</head>
<body>
    <h1>Чат-бот Azure OpenAI</h1>
    <div id="chat-box"></div>
    <input type="text" id="user-input" placeholder="Введите ваше сообщение..." style="width: 80%; padding: 8px;">
    <button onclick="sendMessage()">Отправить</button>

    <script>
        async function sendMessage() {
            const userInput = document.getElementById('user-input');
            const message = userInput.value;
            if (!message) return;

            addMessage('user', message);
            userInput.value = '';

            try {
                const response = await fetch('/chat', {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({ message: message })
                });
                const data = await response.json();
                if (data.response) {
                    addMessage('ai', data.response);
                } else if (data.error) {
                    addMessage('ai', 'Ошибка: ' + data.error);
                }
            } catch (error) {
                addMessage('ai', 'Ошибка сети: ' + error);
            }
        }

        function addMessage(sender, text) {
            const chatBox = document.getElementById('chat-box');
            const msgDiv = document.createElement('div');
            msgDiv.className = 'message ' + sender;
            msgDiv.textContent = `${sender === 'user' ? 'Вы' : 'AI'}: ${text}`;
            chatBox.appendChild(msgDiv);
            chatBox.scrollTop = chatBox.scrollHeight;
        }
    </script>
</body>
</html>

Для локального тестирования убедитесь, что у вас установлен Flask (pip install Flask) и openai (pip install openai). Затем запустите python app.py в терминале и откройте http://127.0.0.1:5000 в браузере. Вы сможете взаимодействовать с чат-ботом, который использует вашу развернутую модель Azure OpenAI.

Разработка простого чат-бота на Flask

Начнем с создания основного файла приложения app.py, который будет обрабатывать логику нашего чат-бота. Мы будем использовать Flask для маршрутизации запросов и интеграции с Azure OpenAI.

Сначала импортируем необходимые библиотеки и инициализируем клиент Azure OpenAI, используя переменные окружения, которые мы настроили ранее:

import os
from flask import Flask, request, jsonify, render_template
from openai import AzureOpenAI

app = Flask(__name__)

# Инициализация клиента Azure OpenAI
client = AzureOpenAI(
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key = os.getenv("AZURE_OPENAI_API_KEY"),
    api_version = "2026-02-01" # Убедитесь, что используете актуальную версию API
)
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")

Далее определим маршруты для нашего приложения. Главная страница (/) будет отображать пользовательский интерфейс чата, который мы разработаем в следующем подразделе.

@app.route('/')
def index():
    return render_template('index.html')

Основная логика чат-бота будет реализована в маршруте /chat, который будет принимать POST-запросы с сообщениями пользователя. Этот маршрут отправит сообщение в Azure OpenAI и вернет сгенерированный ответ.

@app.route('/chat', methods=['POST'])
def chat():
    user_message = request.json.get('message')
    if not user_message:
        return jsonify({"error": "No message provided"}), 400

    try:
        response = client.chat.completions.create(
            model=deployment_name,
            messages=[
                {"role": "system", "content": "Вы полезный ИИ-помощник."},
                {"role": "user", "content": user_message}
            ]
        )
        ai_response = response.choices[0].message.content
        return jsonify({"response": ai_response})
    except Exception as e:
        return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)

Этот код создает базовый Flask-сервер, который принимает сообщения от пользователя, передает их в развернутую модель Azure OpenAI и возвращает ответ. Файл index.html будет отвечать за отображение этого взаимодействия в браузере.

Разработка веб-интерфейса (HTML) и тестирование локально

Теперь, когда серверная часть чат-бота на Flask готова, необходимо создать клиентский интерфейс для взаимодействия с ним. Для этого мы разработаем простой HTML-файл templates/index.html, который будет содержать поле ввода для сообщений пользователя и область для отображения истории чата.

Разработка веб-интерфейса (HTML)

Создайте файл templates/index.html со следующей структурой. Основное внимание уделим JavaScript-части, которая отвечает за отправку сообщений на сервер Flask и отображение ответов:

<!-- ... другие элементы HTML, стили и поле ввода ... -->
<div id="chat-box"></div>
<input type="text" id="user-input" placeholder="Введите ваше сообщение...">
<button onclick="sendMessage()">Отправить</button>

<script>
    async function sendMessage() {
        const userInput = document.getElementById('user-input');
        const message = userInput.value.trim();
        if (!message) return;

        // Отображаем сообщение пользователя
        document.getElementById('chat-box').innerHTML += `<div class="message user">Вы: ${message}</div>`;
        userInput.value = '';

        try {
            const response = await fetch('/chat', { // Отправляем запрос на Flask-сервер
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ message: message })
            });
            const data = await response.json();
            // Отображаем ответ бота
            document.getElementById('chat-box').innerHTML += `<div class="message bot">Бот: ${data.response}</div>`;
        } catch (error) {
            console.error('Ошибка:', error);
            document.getElementById('chat-box').innerHTML += `<div class="message bot" style="color: red;">Ошибка: ${error.message}</div>`;
        }
        document.getElementById('chat-box').scrollTop = document.getElementById('chat-box').scrollHeight;
    }
    document.getElementById('user-input').addEventListener('keypress', (e) => { if (e.key === 'Enter') sendMessage(); });
</script>

Этот JavaScript-код использует fetch API для отправки POST-запросов на маршрут /chat вашего Flask-приложения и динамически обновляет div#chat-box полученными ответами.

Локальное тестирование

Для локального тестирования убедитесь, что ваш файл app.py запущен. Вы можете сделать это, выполнив команду python app.py (или flask run, если вы настроили переменную FLASK_APP). После запуска откройте веб-браузер и перейдите по адресу http://127.0.0.1:5000. Вы сможете взаимодействовать с чат-ботом, отправляя сообщения и получая ответы от Azure OpenAI через ваше Flask-приложение.

Развертывание Python-Приложения в Azure App Service

После успешного локального тестирования нашего Flask-приложения с Azure OpenAI, следующим логичным шагом является его развертывание в облаке. Azure App Service предоставляет масштабируемую и управляемую платформу для хостинга веб-приложений.

Подготовка к развертыванию: requirements.txt и конфигурация

Для корректного развертывания в Azure App Service необходимо убедиться, что все зависимости вашего Python-проекта перечислены в файле requirements.txt. Azure App Service использует этот файл для автоматической установки необходимых пакетов при деплое. Создайте его, если еще не сделали:

pip freeze > requirements.txt

Конфигурация приложения, такая как конечная точка Azure OpenAI и имя развернутой модели, должна быть передана через переменные среды в App Service. Это обеспечивает безопасность и гибкость, позволяя легко менять параметры без изменения кода.

Развертывание с помощью Azure CLI и настройка управляемых удостоверений

Развертывание Flask-приложения в Azure App Service можно выполнить с помощью Azure CLI. Сначала создайте ресурс App Service, а затем разверните ваш код. Пример команды для создания и развертывания:

az webapp up --resource-group <ВАША_ГРУППА_РЕСУРСОВ> --name <ИМЯ_ВАШЕГО_ПРИЛОЖЕНИЯ> --runtime PYTHON:3.10 --sku B1

Для обеспечения максимальной безопасности и упрощения управления учетными данными рекомендуется использовать управляемые удостоверения (Managed Identity) вместо ключей API. После развертывания включите системное управляемое удостоверение для вашего App Service и предоставьте ему роль "Cognitive Services OpenAI User" на ресурсе Azure OpenAI. Это позволит приложению аутентифицироваться в Azure OpenAI без явного хранения секретов.

Подготовка к развертыванию: requirements.txt и конфигурация

Для успешного развертывания вашего Flask-приложения в Azure App Service необходимо тщательно подготовить зависимости и конфигурацию.

Управление зависимостями с requirements.txt

Azure App Service автоматически устанавливает все необходимые пакеты Python, перечисленные в файле requirements.txt. Этот файл должен находиться в корневой директории вашего проекта. Чтобы сгенерировать его, находясь в активированном виртуальном окружении, выполните команду:

pip freeze > requirements.txt

Убедитесь, что в requirements.txt включены все пакеты, используемые вашим приложением, включая flask, openai и python-dotenv (если вы использовали его для локальной разработки).

Конфигурация приложения через переменные среды

Ключи API, конечные точки Azure OpenAI и другие конфиденциальные данные никогда не должны быть жестко закодированы в вашем приложении. Вместо этого используйте переменные среды. В Azure App Service вы можете настроить их как "Параметры приложения" (Application settings), которые затем становятся доступными для вашего приложения как переменные среды.

В вашем Python-коде доступ к этим переменным осуществляется через os.environ:

import os

AZURE_OPENAI_ENDPOINT = os.environ.get("AZURE_OPENAI_ENDPOINT")
AZURE_OPENAI_API_KEY = os.environ.get("AZURE_OPENAI_API_KEY")

Это обеспечивает безопасность и гибкость, позволяя изменять конфигурацию без повторного развертывания кода. После этих шагов ваше приложение готово к развертыванию в облаке.

Развертывание с помощью Azure CLI и настройка управляемых удостоверений

После подготовки проекта к развертыванию, используем Azure CLI для публикации приложения в Службе приложений Azure. Этот метод упрощает процесс, автоматизируя многие шаги конфигурации.

  1. Развертывание приложения с помощью Azure CLI: Перейдите в корневую директорию вашего проекта и выполните следующую команду:

az webapp up —resource-group <ВАША_ГРУППА_РЕСУРСОВ> —name <ИМЯ_ВАШЕГО_ПРИЛОЖЕНИЯ> —runtime PYTHON:3.9 —sku B1 «` Эта команда создаст Службу приложений (если она еще не существует), настроит среду Python и развернет ваше приложение, используя requirements.txt для установки зависимостей.

  1. Настройка управляемых удостоверений (Managed Identity): Для обеспечения максимальной безопасности и исключения необходимости хранения ключей API, настроим системно-назначаемое управляемое удостоверение для вашей Службы приложений.

    • Включение управляемого удостоверения:

az webapp identity assign —resource-group <ВАША_ГРУППА_РЕСУРСОВ> —name <ИМЯ_ВАШЕГО_ПРИЛОЖЕНИЯ> «`

*   **Предоставление разрешений:**
    Получите ID вашего ресурса Azure OpenAI и назначьте роль "Cognitive Services OpenAI User" управляемому удостоверению вашего приложения:
    ```bash

OPENAI_ID=$(az cognitiveservices account show —name <ИМЯ_ВАШЕГО_РЕСУРСА_OPENAI> —resource-group <ВАША_ГРУППА_РЕСУРСОВ> —query id —output tsv) APP_PRINCIPAL_ID=$(az webapp show —name <ИМЯ_ВАШЕГО_ПРИЛОЖЕНИЯ> —resource-group <ВАША_ГРУППА_РЕСУРСОВ> —query identity.principalId —output tsv) az role assignment create —role "Cognitive Services OpenAI User" —assignee $APP_PRINCIPAL_ID —scope $OPENAI_ID «` Теперь ваше приложение может аутентифицироваться в Azure OpenAI, используя DefaultAzureCredential из библиотеки azure-identity, без явного указания ключей API.

Расширенные Возможности и Лучшие Практики

После успешного развертывания и настройки безопасной аутентификации, рассмотрим, как оптимизировать и расширить функциональность вашего приложения.

Работа с различными моделями и параметрами запросов

Azure OpenAI предлагает доступ к различным моделям, включая GPT-4o-mini, GPT-4, а также модели для встраиваний (embeddings). Выбор модели зависит от задачи и бюджета. Для тонкой настройки ответов используйте параметры запроса:

  • temperature: контролирует случайность ответов (0.0 для детерминированных, 1.0 для творческих).

  • max_tokens: максимальное количество токенов в ответе.

  • top_p: альтернатива temperature, фокусирующаяся на вероятностном распределении.

  • stop_sequences: последовательности, при обнаружении которых модель прекращает генерацию.

Экспериментируйте с этими параметрами и методами prompt engineering для достижения наилучших результатов.

Мониторинг, безопасность и масштабирование приложений

Для обеспечения надежности и эффективности:

  • Мониторинг: Используйте Azure Monitor и Application Insights для отслеживания производительности, ошибок и использования API.

  • Безопасность: Помимо управляемых удостоверений, рассмотрите сетевую изоляцию (например, через Приватные конечные точки) для доступа к Azure OpenAI, а также валидацию входных данных.

  • Масштабирование: Azure App Service позволяет легко масштабировать ваше приложение горизонтально для обработки возрастающей нагрузки. Учитывайте лимиты скорости (rate limits) Azure OpenAI и реализуйте механизмы повторных попыток (retry logic) с экспоненциальной задержкой.

Работа с различными моделями и параметрами запросов

Продолжая тему оптимизации ответов, важно понимать, что Azure OpenAI предоставляет доступ к широкому спектру моделей, каждая из которых имеет свои особенности и предназначение. Выбор подходящей модели, такой как gpt-3.5-turbo для быстрых и экономичных решений или gpt-4o-mini для более сложных задач, является первым шагом к достижению желаемого результата. Эффективное использование этих моделей также требует тонкой настройки параметров запросов.

Ключевые параметры, влияющие на генерацию ответов:

  • temperature: Определяет «креативность» модели. Значения от 0 до 1, где более высокие значения делают ответы более случайными и разнообразными, а низкие — более предсказуемыми и сфокусированными.

  • max_tokens: Устанавливает максимальное количество токенов (слов или частей слов) в генерируемом ответе. Это помогает контролировать длину вывода.

  • top_p: Альтернатива temperature, контролирующая разнообразие путем выбора токенов из вероятностного распределения. Например, top_p=0.1 означает, что будут рассмотрены только токены, составляющие 10% верхней вероятностной массы.

  • frequency_penalty и presence_penalty: Эти параметры (от -2.0 до 2.0) влияют на вероятность повторения токенов. frequency_penalty снижает вероятность повторения уже использованных токенов, а presence_penalty — вероятность появления новых тем.

Экспериментирование с этими параметрами позволяет точно настроить поведение модели для конкретных сценариев использования, будь то генерация креативного контента или получение точных, фактических ответов.

Мониторинг, безопасность и масштабирование приложений

После тонкой настройки моделей и параметров запросов, критически важно обеспечить надежность, безопасность и масштабируемость вашего приложения.

  • Мониторинг: Используйте Azure Monitor и Application Insights для отслеживания производительности приложения, использования API Azure OpenAI, ошибок и задержек. Настройте пользовательские метрики и оповещения, чтобы оперативно реагировать на любые аномалии. Логирование запросов и ответов (с учетом конфиденциальности данных) поможет в отладке и оптимизации.

  • Безопасность: Помимо использования управляемых удостоверений (Managed Identities) для аутентификации, рассмотрите применение Приватных конечных точек (Private Endpoints) для Azure OpenAI, чтобы ограничить доступ к вашим моделям только из вашей виртуальной сети. Внедряйте строгий контроль доступа на основе ролей (RBAC) и регулярно проверяйте политики безопасности.

  • Масштабирование: Для обработки растущей нагрузки масштабируйте экземпляры Azure App Service. Учитывайте лимиты скорости (rate limits) Azure OpenAI и реализуйте механизмы повторных попыток (retry logic) с экспоненциальной задержкой. При необходимости рассмотрите распределение нагрузки между несколькими развернутыми моделями или регионами.

Заключение

В этом полном руководстве мы прошли путь от базовой настройки ресурсов Azure OpenAI и подготовки Python-среды до создания интерактивного веб-приложения на Flask и его развертывания в Azure App Service. Мы освоили ключевые методы аутентификации, включая безопасное использование управляемых удостоверений, и научились выполнять запросы к моделям завершения чата.

Вы получили практические навыки по интеграции мощных языковых моделей OpenAI в свои Python-проекты, а также глубокое понимание лучших практик по мониторингу, обеспечению безопасности и масштабированию таких решений. Теперь вы готовы создавать интеллектуальные приложения, используя всю мощь облачной платформы Azure и передовых возможностей искусственного интеллекта.

Продолжайте экспериментировать с различными моделями, параметрами и сценариями использования, чтобы раскрыть полный потенциал Azure OpenAI в ваших разработках и создавать инновационные решения, отвечающие современным требованиям.

Метки:

Добавить комментарий

Реклама
Как правильно расширить PYTHONPATH и включить кастомные директории в переменные окружения виртуального окружения Python?
В мире разработки на Python критически важно понимать концепцию изоляции сред.
  •  2
  •   2026
Что на самом деле возвращает `re.search`, `re.findall` и `re.finditer` в Python при работе с регулярными выражениями?
Модуль re в Python — это мощный инструмент для работы с паттернами в строках.
  •  2
  •   2026
Что такое генератор словарей в Python и как использовать его для создания словарей с условиями?
Генераторы словарей (Dictionary Comprehensions) — это мощная и элегантная конструкция в Python, позволяющая создавать словари в одну строку кода.
  •  2
  •   2026