Быстрый старт с FastAPI и PyTorch для ML-предсказаний

В современном мире разработки программного обеспечения, где скорость и эффективность являются ключевыми критериями успеха, создание высокопроизводительных и масштабируемых веб-приложений с возможностью машинного обучения становится все более востребованным. Наш проект направлен на решение этой актуальной задачи с использованием передовых технологий в области веб-разработки и искусственного интеллекта. Целью проекта является разработка простого, но мощного веб-сервера на основе FastAPI, интегрированного с моделью машинного обучения на PyTorch для выполнения предсказаний в реальном времени.

FastAPI - это современный, быстрый (высокопроизводительный) веб-фреймворк для построения API с Python 3.7+ на основе стандартных типов Python для декларативного описания запросов и ответов, который использует асинхронное программирование. Он позволяет легко создавать надежные и эффективные веб-сервисы, поддерживая автоматическую генерацию документации через Swagger UI и ReDoc, что значительно упрощает разработку и тестирование API.

PyTorch - это открытая библиотека машинного обучения, разработанная Facebook's AI Research lab. PyTorch предоставляет гибкие инструменты и библиотеки для исследований в области искусственного интеллекта, особенно в сегментах глубокого обучения и нейронных сетей. Благодаря своей интуитивно понятной архитектуре и способности легко интегрироваться с другими технологиями, PyTorch является предпочтительным выбором для разработки и деплоймента моделей машинного обучения.

Docker представляет собой платформу для разработки, доставки и запуска приложений в контейнерах. Docker облегчает развертывание приложений, поскольку контейнер содержит все необходимое для его работы: код, библиотеки, системные инструменты и настройки. Использование Docker в проекте позволяет обеспечить легкость, портативность и консистентность среды выполнения вне зависимости от локальной разработки или продакшн среды, а также способствует упрощению процесса CI/CD.

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

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

1. Операционная система: Проект совместим с основными операционными системами, включая Windows, macOS и Linux. Для упрощения процесса развертывания и обеспечения единообразия сред, мы будем использовать Docker, что делает выбор операционной системы менее критичным.
2. Знание языка Python: Поскольку весь проект разрабатывается на Python, наличие уверенных знаний и практического опыта программирования на этом языке является обязательным. Особое внимание стоит уделить асинхронному программированию, с которым тесно связан FastAPI, а также основам работы с библиотеками для машинного обучения, такими как PyTorch.
3. Установленный Python версии 3.7 и выше: Убедитесь, что на вашем компьютере установлена актуальная версия Python, поддерживаемая FastAPI и PyTorch. Это можно проверить, выполнив команду python --version или python3 --version в терминале.
4. Знакомство с FastAPI и PyTorch: Хотя данная статья включает в себя пошаговые инструкции по работе с этими фреймворками, базовое понимание их принципов работы будет значительным преимуществом. Рекомендуется ознакомиться с документацией FastAPI для понимания создания асинхронных API и документацией PyTorch для основ работы с нейронными сетями.
5. Установленный Docker: Docker используется для контейнеризации и развертывания вашего приложения. Это обеспечивает легкость переноса и масштабируемость вашего проекта. Установка Docker доступна на официальном сайте, и следует убедиться в наличии последней версии.
6. Базовые знания о контейнерах и Docker: Понимание основ работы с контейнерами и Docker будет полезным для настройки среды разработки и развертывания приложения. Это включает в себя создание Dockerfile, конфигурацию docker-compose и управление контейнерами.
7. Текстовый редактор или IDE: Наличие удобного средства разработки, такого как Visual Studio Code, PyCharm или любого другого редактора, поддерживающего разработку на Python, упрощает процесс написания и отладки кода.

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

Виртуальное окружение в Python — это изолированная среда, позволяющая устанавливать пакеты и зависимости отдельно для каждого проекта, предотвращая возможные конфликты и несовместимости. Это важный шаг в подготовке к разработке нашего веб-сервера на FastAPI с интеграцией PyTorch, поскольку позволяет точно контролировать версии используемых библиотек и упрощает процесс деплоймента. Далее представлены шаги для создания и активации виртуального окружения:

1. Открытие терминала или командной строки: Для начала необходимо открыть терминал (Linux/macOS) или командную строку/PowerShell (Windows).

2. Переход в директорию проекта: Используйте команду cd для перехода в папку, где будет расположен ваш проект, например:

   cd путь/до/вашего/проекта

3. Создание виртуального окружения: Введите следующую команду для создания виртуального окружения внутри папки проекта. Обратите внимание, что venv — это имя папки для виртуального окружения, его можно изменить на любое другое:

   • Для Windows:

     python -m venv venv

   • Для macOS и Linux:

     python3 -m venv venv

4. Активация виртуального окружения: После создания виртуального окружения его необходимо активировать, чтобы использовать его в качестве основной среды разработки:

   • Для Windows:

     .\venv\Scripts\activate

   • Для macOS и Linux:

     source venv/bin/activate

   После активации виртуального окружения вы увидите его название в начале строки в терминале, что указывает на то, что все последующие команды python и pip будут использовать изолированное окружение.

5. Обновление менеджера пакетов: Для обеспечения использования последних версий pip, setuptools и wheel, выполните следующую команду:

   python -m pip install --upgrade pip setuptools wheel

   Это шаг обеспечит более гладкую установку других пакетов и зависимостей.

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

1. Подготовка файла requirements.txt: В корне вашего проекта создайте файл requirements.txt, который будет содержать список всех необходимых пакетов с указанием их версий. Пример содержимого файла:

   fastapi~=0.109.2
   pydantic-settings~=2.2.1
   uvicorn~=0.28.0
   
   --find-links https://download.pytorch.org/whl/torch_stable.html
   torch==2.2.1+cpu
   
   transformers[torch]

   В этом файле указаны основные зависимости: FastAPI для веб-фреймворка, Uvicorn как ASGI сервер для запуска FastAPI, Pydantic для валидации и управления настройками через pydantic-settings, PyTorch для работы с нейронными сетями и transformers для использования предварительно обученных моделей.

2. Установка PyTorch: В связи с тем, что PyTorch может требовать специальной предварительной настройки для установки, особенно если вы хотите использовать версию, оптимизированную для работы с GPU, вам может понадобиться следовать инструкциям с официального сайта PyTorch. Однако, для большинства случаев, установка CPU-версии, указанной в requirements.txt, будет достаточной. Убедитесь, что в вашем requirements.txt указана ссылка на совместимую версию PyTorch, как показано выше.

3. Установка зависимостей из файла requirements.txt: Выполните следующую команду в терминале, находясь в корневой директории проекта, чтобы установить все указанные зависимости:

   python -m pip install -r requirements.txt

   Если ваш проект требует установки PyTorch с поддержкой GPU, следуйте специальным инструкциям с официального сайта PyTorch для выбора подходящего варианта установки.

4. Установка дополнительных пакетов: В зависимости от специфики вашего проекта, может потребоваться установка дополнительных пакетов и библиотек. Это может быть выполнено по мере необходимости с помощью команды pip install имя_пакета или/и добавлено в requirements.txt.

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

predict/
│
├── src/                           # Исходный код приложения
│   ├── config/                    # Конфигурации приложения
│   │   └── settings.py            # Глобальные настройки проекта
│   │
│   ├── predictions/               # Модуль задач предсказаний
│   │   ├── routers.py             # Роутеры FastAPI для обработки запросов
│   │   └── schemas.py             # Pydantic схемы для валидации данных
│   │
│   └── main.py                    # Основной файл FastAPI приложения
│
├── venv/                          # Виртуальное окружение Python
│
├── .env                           # Файл для переменных окружения
│
├── requirements.txt               # Зависимости проекта
│
├── .dockerignore                  # Файлы игнорируемые при сборке
│
├── Dockerfile                     # Для сборки Docker-контейнера
│
└── docker-compose.yml             # Управление контейнерами Docker

Подробно рассмотрим назначение основных компонентов структуры:

• src/: Эта папка содержит весь исходный код нашего приложения. Разделение кода на модули и пакеты упрощает его управление и тестирование.
• src/config/: Здесь хранятся файлы конфигурации проекта, такие как настройки, связанные с базой данных, внешними сервисами и другими параметрами, которые могут меняться в зависимости от среды выполнения приложения.
• src/tasks/: В этом каталоге расположены файлы, относящиеся к обработке и выполнению задач предсказаний. Включает в себя роутеры для обработки HTTP-запросов и схемы Pydantic для валидации входящих данных.
• src/main.py: Основной файл приложения, в котором инициализируется и конфигурируется экземпляр FastAPI. Здесь также происходит подключение всех роутеров и других компонентов приложения.
• venv/: Папка виртуального окружения, которая содержит все необходимые библиотеки Python, используемые в проекте, и изолирует их от остальной системы.
• .env: Файл для хранения переменных окружения, таких как секретные ключи и параметры конфигурации, необходимые для работы приложения в различных средах.
• requirements.txt: Список всех зависимостей Python, необходимых для работы проекта. Этот файл используется для упрощения установки зависимостей в новом окружении.
• Dockerfile, docker-compose.yml и .dockerignore: Файлы для настройки и управления Docker-контейнерами, позволяющие легко развертывать и запускать приложение в любой среде, поддерживающей Docker.

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

При разработке веб-приложений на FastAPI с использованием PyTorch и контейнеризации через Docker, некоторые файлы играют основную роль в конфигурации, развертывании и управлении зависимостями проекта. Более детально рассмотрим назначение и содержимое трех важных файлов: requirements.txt, Dockerfile, и docker-compose.yml.

Файл requirements.txt содержит список всех внешних пакетов Python, которые требуются для вашего проекта, вместе с их версиями. Это обеспечивает легкость установки и управления зависимостями, позволяя воспроизвести одинаковую среду на различных машинах и в разных средах. 

Dockerfile – это текстовый файл, содержащий все необходимые команды, на основе которых происходит сборка образа Docker для вашего приложения. Этот файл следует в корне проекта и описывает базовый образ, необходимые для установки пакеты, копирование файлов проекта в контейнер, и команды для запуска приложения.

Файл docker-compose.yml используется для определения и запуска многоконтейнерных приложений Docker. В контексте нашего проекта, он может использоваться для упрощения процесса сборки, развертывания и управления контейнером приложения, а также для организации дополнительных сервисов, таких как базы данных или системы кеширования. Ниже мы рассмотрим контеризацию более детально.

Важным аспектом разработки современных веб-приложений является централизованное управление конфигурацией. В FastAPI, эффективное управление настройками обеспечивается через модуль settings.py. Этот файл служит для объявления и доступа к глобальным настройкам проекта, включая пути к каталогам, параметры модели, а также переменные окружения.

Создание settings.py

Файл settings.py размещается в директории src/config проекта и содержит определение класса Settings, наследующего от BaseSettings библиотеки pydantic-settings. Это позволяет легко интегрировать переменные окружения и задавать настройки по умолчанию. Пример содержания файла settings.py:

from pathlib import Path
from pydantic_settings import BaseSettings, SettingsConfigDict

class Settings(BaseSettings):
    # Определение настроек, загружаемых из переменных окружения, если требуется
    model_config: SettingsConfigDict = SettingsConfigDict(env_prefix='MODEL_')

    @property
    def base_dir(self) -> Path:
        # Автоматическое определение корневой директории проекта
        return Path(__file__).resolve().parent.parent

settings = Settings()

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

• model_config используется для загрузки конфигурационных параметров модели, предварительно определенных в переменных окружения с префиксом MODEL_.
• Свойство base_dir позволяет определить и использовать путь к корневой директории проекта, что упрощает доступ к ресурсам и модулям внутри проекта.
• Создается экземпляр settings, через который доступны все определенные настройки.

Интеграция settings.py в приложение

Для использования определенных в settings.py настроек в других частях приложения, достаточно импортировать экземпляр settings и обращаться к его атрибутам:

from ..config.settings import settings

# Использование пути к корневой директории проекта
base_dir = settings.base_dir

# Доступ к конфигурационным параметрам модели
model_config = settings.model_config

Немного теории: FastAPI — это современный, быстрый веб-фреймворк для создания API с Python 3.7+ на основе асинхронного программирования, который позволяет строить масштабируемые и эффективные веб-приложения. Настройка основного приложения FastAPI включает в себя несколько шагов, начиная от инициализации приложения до его конфигурации для обработки запросов.

1. Инициализация приложения FastAPI:

   • В первую очередь, необходимо создать экземпляр приложения FastAPI. Для этого в файле src/main.py импортируем класс FastAPI из библиотеки fastapi и инициализируем его:

     from fastapi import FastAPI
     
     app = FastAPI()

   • Этот экземпляр app будет центральным элементом вашего веб-приложения, через который будут проходить все запросы и ответы.
2. Пример добавление маршрутов (роутов):

   • Далее, к экземпляру приложения можно добавлять маршруты — спецификации эндпоинтов API, по которым будут обрабатываться запросы. Например, добавим простой маршрут для демонстрации:

     @app.get("/")
     async def read_root():
         return {"Hello": "World"}

   • Здесь мы создали маршрут корневого эндпоинта ("/"), который обрабатывает GET-запросы и асинхронно возвращает простое приветственное сообщение в формате JSON.
3. Конфигурация и использование Pydantic моделей для валидации:

   • FastAPI позволяет использовать модели Pydantic для валидации входящих данных. Это обеспечивает строгую типизацию и автоматическую документацию для вашего API. Например, определим модель Pydantic в файле src/tasks/schemas.py:

     from pydantic import BaseModel
     
     class QueryText(BaseModel):
         text: str

   • И используем её в роутере для валидации входных данных:

     @app.post("/predict/")
     async def get_prediction(item: QueryText):
         return {"text": item.text}

4. Настройка CORS (Cross-Origin Resource Sharing):

   • Для того, чтобы ваше API могло быть безопасно доступно из браузеров на других доменах, необходимо настроить CORS. Это можно сделать с помощью middleware в FastAPI:

     from fastapi.middleware.cors import CORSMiddleware
     
     app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"],  # Список доменов, для которых разрешены запросы
         allow_credentials=True,
         allow_methods=["*"],  # Разрешенные методы запросов
         allow_headers=["*"],  # Разрешенные заголовки
     )

5. Запуск приложения:

   • Чтобы запустить разработанный веб-сервер, используйте ASGI-сервер, например, Uvicorn. Запустите его из командной строки, указав файл и объект приложения:

     uvicorn src.main:app --reload

   • Флаг --reload делает сервер перезагружаемым при изменении кода, что удобно во время разработки.

Эти шаги позволяют понять как настроить базовое приложение FastAPI.

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

1. Создание роутера:

   • Для начала, создадим отдельный файл для наших роутеров внутри модуля (например, src/tasks/routers.py). В этом файле импортируем необходимые модули и создаем экземпляр APIRouter из FastAPI:

     from fastapi import APIRouter
     
     router = APIRouter()

   • Затем, к примеру можно добавить к этому роутеру различные маршруты (эндпоинты), используя декораторы, аналогичные тем, что используются в основном приложении (@app.get(), @app.post() и т.д.), но применяя их к экземпляру router.
2. Регистрация роутера в приложении:

   • После создания роутера и определения в нем необходимых маршрутов, следующим шагом будет его регистрация в основном приложении FastAPI. Вернемся к файлу src/main.py, где инициализируется основной экземпляр приложения:

     from fastapi import FastAPI
     from .predictions.routers import router as predictions_router
     
     app = FastAPI()
     
     app.include_router(predictions_router, prefix="/predictions", tags=["predictions"])

   • Здесь метод include_router используется для добавления всех маршрутов из роутера predict_router в основное приложение. Параметр prefix добавляет указанный префикс ко всем URL-адресам в роутере, а tags помогают группировать эндпоинты в документации API.
3. Организация кода и разделение логики:
   • Используя роутеры, вы можете эффективно разделять логику вашего приложения на несколько модулей или компонентов. Например, можно создать отдельные роутеры для различных частей приложения, таких как управление пользователями, обработка задач и т.д.
   • Это не только упрощает навигацию по коду и его поддержку, но и облегчает масштабирование приложения, позволяя добавлять новые функции и эндпоинты без значительного усложнения структуры проекта.

Использование моделей машинного обучения, разработанных с помощью PyTorch, для выполнения предсказаний в веб-приложениях на FastAPI, требует предварительной подготовки и загрузки этих моделей. Этот процесс включает несколько ключевых шагов, начиная от выбора модели до ее интеграции и тестирования в вашем API. Давайте рассмотрим, как подготовить модель PyTorch к использованию в вашем веб-приложении.

1. Выбор модели:
   • Определите, какую задачу вы хотите решить с помощью модели машинного обучения (например, классификацию текста, распознавание изображений и т.д.) и выберите подходящую предварительно обученную модель из библиотеки transformers или любую другую модель, обученную вами. Важно, чтобы модель соответствовала вашим требованиям по точности и производительности.
2. Загрузка и сохранение модели:

   • Если вы используете предварительно обученную модель, загрузите ее с помощью соответствующего API. Для моделей из transformers это может выглядеть следующим образом:

     from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
     
     model_name = "distilbert-base-uncased-finetuned-sst-2-english"
     model = DistilBertForSequenceClassification.from_pretrained(model_name)
     tokenizer = DistilBertTokenizer.from_pretrained(model_name)
     
     ... манипуляции для дообучения модели
     trainer.train()

   • После, модель и токенизатор можно сохранить локально, чтобы избежать необходимости загружать их каждый раз при запуске приложения:

     model.save_pretrained('./model')
     tokenizer.save_pretrained('./model')

3. Загрузка модели в приложение:

   • При старте вашего FastAPI приложения загрузите модель и токенизатор из локального хранилища. Это обеспечит быстрый доступ к модели при обработке запросов:

     model = DistilBertForSequenceClassification.from_pretrained('./model')
     tokenizer = DistilBertTokenizer.from_pretrained('./model')

   • Убедитесь, что эта операция выполняется единожды при инициализации приложения, чтобы минимизировать задержку при обработке каждого запроса.
4. Подготовка данных для предсказаний:

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

     inputs = tokenizer("Пример текста для анализа", padding=True, truncation=True, return_tensors="pt")

5. Выполнение предсказаний:

   • С использованием подготовленных данных выполните предсказание с помощью модели:

     with torch.no_grad():
         outputs = model(**inputs)

   • Обработайте выходные данные модели (например, преобразование логитов в вероятности с помощью softmax) для получения окончательных результатов предсказания. 

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

После подготовки модели PyTorch к использованию следующим шагом является создание endpoint'а в вашем FastAPI приложении, который будет принимать данные от пользователей, обрабатывать их и возвращать результаты предсказаний. Реализация такого API требует внимательного подхода к деталям для обеспечения точности и эффективности предсказаний. Давайте разберемся, как можно создать и настроить такой endpoint.

1. Определение эндпоинта для предсказаний:

   • В файле роутера (например, src/tasks/routers.py), определим новый маршрут, который будет принимать данные для предсказания через POST-запрос. Используем модель Pydantic для валидации входящих данных:

     from fastapi import APIRouter, HTTPException, status
     from .schemas import Task
     from .model_utils import predict
     
     router = APIRouter()
     
     @router.post("/predict/", status_code=status.HTTP_200_OK)
     async def get_prediction(item: QueryText):
         try:
             prediction = await predict(item.text)
             return {"prediction": prediction}
         except Exception as e:
             raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))

     Здесь QueryText — это модель Pydantic, определяющая структуру входящего запроса, а функция predict — это ваша пользовательская функция для выполнения предсказания с использованием загруженной модели PyTorch.

2. Реализация функции предсказания:

   • В модуле src/model_utils.py реализуем функцию predict, которая будет принимать текст, подготавливать его к обработке моделью и возвращать результат предсказания:

     import torch
     from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
     from ..config.settings import settings
     
     # Предварительная загрузка модели и токенизатора
     model_path = f"{settings.base_dir}/tasks/model"
     model = DistilBertForSequenceClassification.from_pretrained(model_path)
     tokenizer = DistilBertTokenizer.from_pretrained(model_path)
     
     async def predict(text: str):
         inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
         with torch.no_grad():
             outputs = model(**inputs)
         logits = outputs.logits
         predictions = torch.softmax(logits, dim=-1)
         predicted_class = predictions.argmax().item()
         # Пример возвращаемого значения может быть индексом класса, который затем можно интерпретировать
         return predicted_class

     В этом примере данные преобразуются в формат, подходящий для модели, выполняется предсказание, а результаты возвращаются в вызывающую функцию.

3. Тестирование эндпоинта:
   • После создания эндпоинта и функции предсказания необходимо провести тестирование, чтобы убедиться в их корректной работе. Вы можете использовать инструменты для тестирования API, такие как Postman, или документацию Swagger, автоматически генерируемую FastAPI, для отправки запросов на ваш эндпоинт и проверки ответов.

Контейнеризация — ключевой шаг в подготовке приложений к деплою и тестированию, обеспечивающий их портативность, консистентность и легкость в управлении. Используя Docker, вы можете легко упаковать ваше приложение вместе с его зависимостями в контейнер, который может быть запущен на любой системе с Docker, независимо от особенностей окружения. Далее представлены основные шаги по созданию Dockerfile, .dockerignore и конфигурации docker-compose.yml для приложения на FastAPI.

Создание Dockerfile

Dockerfile определяет инструкции для сборки образа Docker вашего приложения. Создайте Dockerfile в корне проекта с следующим содержанием:

# Используем официальный образ Python как базовый
FROM python:3.11-slim

# Устанавливаем рабочую директорию внутри контейнера
WORKDIR /app

# Копируем файл зависимостей в рабочую директорию
COPY ./requirements.txt .

# Устанавливаем зависимости
RUN pip install --no-cache-dir -r requirements.txt

# Копируем остальные файлы проекта в контейнер
COPY . .

# Задаем команду для запуска приложения
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]

Этот Dockerfile создает образ, основанный на легковесной версии официального образа Python, устанавливает необходимые зависимости из файла requirements.txt и задает команду для запуска сервера FastAPI через Uvicorn.

Настройка .dockerignore

Добавление файла .dockerignore в корневую директорию вашего проекта позволяет Docker игнорировать указанные файлы и папки при сборке образа. Вот как это может выглядеть:

**.venv
**__pycache__
**.pyc
**.pyo
**.pyd
**.DS_Store
**.env
**.env.local
**Dockerfile
**docker-compose.yml

Этот файл указывает Docker игнорировать:

• Виртуальное окружение .venv, которое не требуется в образе, так как все зависимости должны быть установлены в самом образе.
• Кэш Python __pycache__, а также скомпилированные файлы .pyc, .pyo, .pyd, которые не нужны для выполнения приложения в контейнере.
• Файлы .DS_Store, создаваемые macOS, и файлы конфигурации окружения .env, .env.local, которые могут содержать чувствительные данные, не предназначенные для размещения в общем доступе.

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

Конфигурация docker-compose

Файл docker-compose.yml упрощает управление вашим Docker-контейнером, позволяя описать и запустить мультиконтейнерные приложения. Создайте файл docker-compose.yml в корне проекта с таким содержанием:

version: '3.8'
services:
  predict:
    build: .
    container_name: fastapi-pytorch-app
    ports:
      - "8000:8000"    
    env_file:
      - ./.env # если необходимо подтянуть переменные окружения
    command: uvicorn src.main:app --host 0.0.0.0 --reload

Здесь сервис web настраивается для сборки образа на основе Dockerfile в текущем каталоге, пробрасывает порты для доступа к приложению извне и использует тома для синхронизации кода между хост-машиной и контейнером, что упрощает разработку и тестирование.

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

1. Запуск сервера:

   • Если вы следовали предыдущим шагам по созданию Dockerfile и docker-compose.yml, запустить сервер очень просто. В терминале, находясь в корневом каталоге проекта, выполните следующую команду:

     docker-compose up --build

   • Эта команда соберет образ Docker и запустит контейнер. Вывод в терминале покажет логи сервера, включая сообщения о его запуске и обработке запросов.
2. Проверка доступности API:
   • После запуска сервера убедитесь, что ваш API доступен. Откройте браузер и перейдите по адресу http://localhost:8000. Если вы включили автоматическую генерацию документации FastAPI, вы увидите интерфейс Swagger UI, который позволяет исследовать и тестировать ваш API прямо из браузера.
3. Тестирование функциональности API:
   • Используя интерфейс Swagger UI или инструменты для тестирования API, такие как Postman, выполните несколько тестовых запросов к вашему API. Это может быть запрос на получение данных, если API поддерживает такую операцию, или запрос на выполнение предсказания, если API интегрирован с моделью машинного обучения.

   • Пример запроса для API, обрабатывающего предсказания:

     POST predictions/predict/
     {
       "text": "Текст для анализа"
     }

   • Отправьте запрос и оцените ответ сервера. Успешный ответ подтвердит корректную работу вашего API и интеграции с моделью машинного обучения.
4. Логирование и отладка:
   • В процессе тестирования обратите внимание на логи сервера в терминале. Они могут предоставить ценную информацию при поиске и исправлении ошибок, а также помогут оценить производительность и эффективность обработки запросов.
5. Остановка сервера:
   • После завершения тестирования остановите сервер, нажав Ctrl+C в терминале, где он запущен, или выполнив команду docker-compose down, чтобы остановить и удалить контейнеры, созданные с помощью docker-compose.

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