Книга «Микросервисы и API»

Привет, Хаброжители!

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

Книга наполнена проверенными советами и примерами кода на языке Python. Авторы фокусируются на реализации, а не на философии. Изучите проверенные методы проектирования простых в использовании API для микросервисных приложений. Создавайте надежные API микросервисов, тестируйте, защищайте и развертывайте их в облаке, следуя принципам и шаблонам, применимым в любом языке программирования.

Для кого эта книга

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

Примеры кода приведены на языке Python, однако вам не обязательно его знать, чтобы выполнять их. Перед введением нового кода каждая концепция подробно объясняется.

В книге много внимания уделяется стратегиям проектирования, лучшим практикам и процессам разработки, поэтому она также будет полезна техническим директорам (CTO), архитекторам и вице-президентам по разработкам (VP of engineering), которым необходимо решить, стоит ли их компании внедрять микросервисную архитектуру, или тем, кому необходимо сделать выбор между различными стратегиями разработки API и заставить интеграции работать.

Структура книги

Книга состоит из четырех частей, разделенных на 14 глав.

Часть I знакомит с концепциями микросервисов и API. В ней объясняется, как разработать простой API и спроектировать микросервисную систему.

• В главе 1 вводятся основные понятия книги: микросервисы и API. Из нее вы узнаете, чем микросервисы отличаются от монолитной архитектуры и когда имеет смысл использовать монолит, а не микросервисы. Объясняется, что такое API и как они помогают осуществлять интеграцию микросервисов.
• Глава 2 предлагает пошаговое руководство по реализации простого API с помощью популярного в Python фреймворка FastAPI. Вы научитесь читать спецификацию API и понимать ее требования. Вы также узнаете, как поэтапно создавать API и как тестировать модели валидации данных.
• В главе 3 объясняется, как спроектировать микросервисную систему. В ней описаны три фундаментальных принципа проектирования микросервисов, а также объясняется, как разделить систему на микросервисы, используя декомпозицию по бизнес-функциям и декомпозицию по модулям (поддоменам).

Часть II объясняет, как проектировать, документировать и разрабатывать REST API, а также как разработать микросервис.

• В главе 4 рассматриваются принципы проектирования REST API. В ней представлены шесть ограничений архитектуры REST и модель зрелости Ричардсона, а затем объясняется, как мы используем протокол HTTP для разработки хорошо структурированных и понятных REST API.
• В главе 5 рассказывается, как документировать REST API, используя стандарт спецификации OpenAPI. Вы освоите основы синтаксиса схемы JSON (JSON Schema), узнаете, как определять конечные точки, или эндпоинты (endpoints), моделировать данные и рефакторить документацию с помощью многократно используемых схем.
• В главе 6 объясняется, как создавать REST API с помощью двух популярных фреймворков Python: FastAPI и Flask. Вы прочтете о различиях между ними и узнаете, что принципы и модели построения API остаются неизменными и выходят за рамки деталей реализации любого технического стека.
• В главе 7 приводятся фундаментальные принципы и паттерны для построения микросервисов. В ней описана концепция гексагональной архитектуры и объясняется, как обеспечить слабую связанность между уровнями приложения. Вы также узнаете, как реализовать модели баз данных с помощью ORM SQLAlchemy и как управлять миграциями баз данных с помощью Alembic.

В части III объясняется, как проектировать, использовать и разрабатывать GraphQL API.

• В главе 8 рассказывается, как разрабатывать GraphQL API и как использовать Schema Definition Language (SDL).. В ней описываются стандартные типы GraphQL, а также объясняется, как определить кастомные типы. Вы узнаете, как создавать связи между типами и писать запросы и мутации.
• В главе 9 мы поговорим о том, как использовать GraphQL API. Вы узнаете, как запустить mock-сервер и изучить документацию GraphQL с помощью GraphiQL.. Вы научитесь отправлять запросы и мутации на сервер GraphQL и при этом использовать параметры.
• В главе 10 рассказывается о том, как создавать GraphQL API с помощью Python фреймворка Ariadne. Вы научитесь использовать документацию API для автоматической загрузки моделей валидации данных, а также создавать резольверы для кастомных типов, запросов и мутаций.

В части IV объясняется, как тестировать, делать безопасным и развертывать API микросервисов.

• В главе 11 вы узнаете, как добавить аутентификацию и авторизацию в ваши API с помощью стандартных протоколов, таких как OpenID Connect (OIDC) и Open Authorization (OAuth) 2.1. Мы обсудим, как создавать и валидировать JSON Web Tokens (JWT) и как разработать слой авторизации для ваших API.
• В главе 12 рассказывается о том, как тестировать и валидировать API. Вы узнаете, что такое тестирование на основе свойств (property-based testing, PBT) и как использовать его для проверки API, а также научитесь работать с фреймворками для автотестирования, в частности Dredd и schemathesis.
• В главе 13 объясняется, как упаковать микросервисы в Docker-контейнеры, запускать их локально с помощью Docker Compose и как публиковать Docker-образы в AWS Elastic Container Registry (ECR).
• В главе 14 мы обсудим развертывание микросервисов в облаке AWS с помощью Kubernetes. Вы узнаете, как создать кластер Kubernetes и управлять им с помощью Elastic Kubernetes Service AWS, как запустить бессерверную базу данных Aurora в защищенной сети, как безопасно развернуть конфиг-файл приложения с помощью шифрования по схеме envelope encryption и как развернуть сервисы с возможностью последующего масштабирования.

На протяжении всех глав мы будем работать над созданием компонентов для вымышленной платформы доставки кофе, которая называется CoffeeMesh. В главе 1 приводится вводная информация о CoffeeMesh, а в главе 3 описывается, как разделить платформу на микросервисы. Поэтому я рекомендую прочитать главы 1 и 3, чтобы лучше понять примеры, приведенные в последующих главах. В остальном все части независимы и все главы самодостаточны. Например, если вы хотите узнать, как проектировать и разрабатывать REST API, можете сразу перейти к части II, а если вас интересует GraphQL API, можете сосредоточиться на части III. Точно так же, если вы хотите научиться добавлять аутентификацию и авторизацию в ваши API, переходите к главе 11 или, если хотите научиться тестировать API, вам в помощь глава 12.

Контейнеризация API микросервисов

Docker — это контейнеризатор приложений, программное обеспечение для автоматизации развертывания приложений и управления ими в средах с поддержкой контейнеризации. Он позволяет запускать приложения в любом месте, просто используя среду выполнения Docker, и избавляет от необходимости настраивать среду для запуска кода. Так развертывания становятся более предсказуемыми, поскольку Docker создает воспроизводимые артефакты (образы контейнеров), которые можно запускать как локально, так и в облаке.

В этой главе вы научитесь контейнеризовать приложение на Python. Контейнеризация (докеризация) — это процесс упаковки приложения в виде образа Docker. Вы можете думать об образе Docker как о сборке или артефакте, который готов к развертыванию и выполнению. Чтобы запустить образ, Docker создает запущенные экземпляры образа, известные как контейнеры. Для развертывания образов Docker обычно используют оркестратор контейнеров, такой как Kubernetes, который управляет жизненным циклом контейнера. В следующей главе вы узнаете, как развертывать Docker-образы с помощью Kubernetes. Мы разберемся, как контейнеризовать приложение с помощью сервиса заказов платформы CoffeeMesh.. Вы также научитесь публиковать свои Docker-образы в реестре контейнеров, загружая образы в Elastic Container Registry AWS (ECR).

Все примеры кода доступны в папке ch13 в репозитории GitHub для этой книги. Начнем с настройки среды для работы.

НАСТРОЙКА СРЕДЫ ДЛЯ ЭТОЙ ГЛАВЫ

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

$ cp -r ch11 ch13

Перейдите в нее, установите зависимости и активируйте виртуальную среду, выполнив следующие команды:

$ cd ch13 && pipenv install --dev && pipenv shell

Когда мы развертываем приложение, мы используем движок PostgreSQL, который является одним из самых популярных движков SQL для запуска приложений в рабочей среде. Для связи с базой данных используем psycopg2 — один из самых популярных драйверов PostgreSQL для Python:

$ pipenv install psycopg2

УСТАНОВКА PSYCOPG2

Если вы столкнетесь с проблемами при установке и компиляции psycopg2, попробуйте установить скомпилированный пакет, запустив pipenv install psycopg2-binary, или возьмите файлы ch13/Pipfile и ch13/Pipfile.lock в репозитории к этой книге на GitHub и запустите pipenv install --dev. Еще два мощных драйвера PostgreSQL — это asyncpg (https://github.com/MagicStack/asyncpg) и pscycopg3 (https://github.com/psycopg/psycopg), оба поддерживают асинхронные операции. Очень рекомендую вам ознакомиться с ними.

Чтобы создавать и запускать контейнеры Docker, вам понадобится среда выполнения Docker на компьютере. Инструкции по установке зависят от конкретной платформы, поэтому ознакомьтесь с официальной документацией, чтобы узнать, как установить Docker в своей системе (https://docs.docker.com/get-docker/).

Поскольку мы собираемся опубликовать наши образы Docker в ECR AWS, нам необходимо установить AWS CLI:

$ pipenv install --dev awscli

Далее перейдите на сайт https://aws.amazon.com/. Создайте учетную запись AWS и получите ключ доступа, чтобы иметь возможность программного доступа к сервисам AWS. Пользователь, через которого вы создаете учетную запись AWS, будет root-пользователем. В целях безопасности рекомендуется не использовать пользователя root для генерации ключа доступа. Вместо этого создайте пользователя IAM и сгенерируйте ключ доступа для него. IAM — это сервис управления идентификацией и контролем доступа AWS, который позволяет создавать пользователей, роли и детализированные политики для предоставления доступа к другим сервисам в вашей учетной записи. Ознакомьтесь с документацией AWS, чтобы узнать, как создать пользователя IAM (http://mng.bz/neP8) и как сгенерировать ключи доступа и настроить AWS CLI (http://mng.bz/vXxq).

Теперь, когда среда готова, пришло время упаковать наши приложения!

КОНТЕЙНЕРИЗАЦИЯ МИКРОСЕРВИСА

Что такое контейнеризация приложения? Это процесс упаковки приложения в виде образа Docker. Представляйте себе образ Docker как сборку или артефакт, который может быть развернут и выполнен во время работы Docker. Все системные зависимости уже установлены в образе, и для его запуска нужна только среда выполнения Docker. Запуская образ, Docker создает контейнер, который является запущенным экземпляром образа. Как вы можете видеть на рис. 13.1, работать с Docker очень легко, поскольку он позволяет запускать приложения в изолированных процессах. Существуют различные варианты установки среды выполнения Docker в зависимости от вашей платформы, поэтому ознакомьтесь с официальной документацией, чтобы определить, какой вариант вам лучше всего подходит (https://docs.docker.com/get-docker/).

В этом разделе мы создадим оптимизированный Docker-образ сервиса заказов. Попутно вы узнаете, как написать Dockerfile, который представляет собой документ со всеми инструкциями на тему создания образа Docker. Вы также узнаете, как запускать контейнеры Docker и сопоставлять порты из контейнера с операционной системой хоста, чтобы вы могли взаимодействовать с приложением, запущенным внутри контейнера. Наконец, вы узнаете, как управлять контейнерами с помощью Docker CLI.

ОСНОВЫ DOCKER

Если вы хотите узнать больше о том, как работает Docker и как он взаимодействует с операционной системой хоста, ознакомьтесь с главой Docker Fundamentals («Основы Docker») из книги Прабата Сиривардены и Нувана Диаса Microservices Security in Action (Manning, 2020, http://mng.bz/49Ag).

Прежде чем мы создадим образ, нам нужно внести два небольших изменения в код приложения, чтобы подготовить его к развертыванию. До сих пор сервис заказов использовал жестко запрограммированный URL-адрес базы данных, но для работы сервиса в различных средах нам необходимо настроить этот параметр. В листинге 13.1 показан код с изменениями в файле orders/repository/unit_of_work.py для извлечения URL-адреса базы данных из среды. Недавно добавленный код выделен жирным шрифтом. Мы используем оператор контроля ошибок (assert) для немедленного выхода из приложения, если URL-адрес базы данных не указан.

Нам также нужно обновить файлы Alembic, чтобы извлечь из среды URL-адрес базы данных. В листинге 13.2 показано, какие изменения необходимо внести в файл migrations/env.py, новый код выделен жирным шрифтом. Я опустил несущественные части кода, чтобы было легче наблюдать за изменениями.

Теперь, когда наш код готов, пришло время его упаковать. Чтобы создать образ Docker, нужно написать Dockerfile. В листинге 13.3 приводится его содержимое. Мы используем неполную версию официального образа Python 3.9 Docker в качестве базового. Неполные образы содержат только те зависимости, которые требуются для запуска приложений, то есть мы получим более легкий образ. Чтобы использовать базовый образ, мы используем директиву Docker FROM. Затем создаем папку для кода приложения под названием /orders/orders. Для запуска команд bash, в частности mkdir в нашем случае, мы используем директиву RUN. Устанавливаем /orders/orders в качестве рабочего каталога, используя директиву WORKDIR. Рабочий каталог — это каталог, из которого запускается приложение.

Далее устанавливаем pipenv, копируем наши файлы Pipenv и определяем зависимости. Для копирования файлов из файловой системы в образ Docker мы используем директиву COPY. Поскольку мы работаем в Docker, нам не нужна виртуальная среда, поэтому устанавливаем зависимости, используя флаг pipenv --system. Добавляем также флаг pipenv –deploy — так мы проверим актуальность файлов Pipenv. Наконец, копируем исходный код и указываем команду, которую следует выполнить, чтобы запустить сервис заказов. Она будет указана с помощью директивы CMD. Используем также директиву EXPOSE, чтобы убедиться, что запущенный контейнер прослушивает порт 8000 — именно на нем работает наш API. Если мы не откроем порт, то не сможем взаимодействовать с API.

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

Чтобы создать образ Docker из листинга 13.3, вам необходимо запустить из каталога ch13 следующую команду:

$ docker build -t orders:1.0 .

Флаг -t обозначает тег. Тег Docker состоит из двух частей: названия образа (слева от двоеточия) и названия тега (справа от двоеточия). Имя тега — это обычно версия образа. В данном случае мы присваиваем порядкам образов имена и помечаем их значением 1.0. Убедитесь, что вы не пропустили точку в конце инструкции build: она означает текущий каталог в пути к исходному коду образа (контекст на языке Docker).

Как только образ будет создан, вы можете выполнить его с помощью такой команды:

$ docker run --env DB_URL=sqlite:///orders.db \
-v $(pwd)/orders.db:/orders/orders.db -p 8000:8000 -it orders:1.0

Как видно на рис. 13.2, флаг --env позволяет устанавливать переменные окружения в контейнере, и мы используем его для установки URL-адреса базы данных. Чтобы сделать приложение доступным для хост-машины, добавляем флаг -p, который позволяет нам привязать порт, на котором приложение запущено внутри контейнера, к порту на хост-машине. Мы также указываем флаг -v для подключения тома к файлу базы данных SQLite. Тома Docker позволяют контейнерам получать доступ к файлам из файловой системы хост-компьютера.

Теперь вы можете получить доступ к приложению по URL-адресу http://127.0.0.1:8000/docs/orders. Предыдущая команда запускает контейнер, подключенный к текущему сеансу терминала, что позволяет вам видеть, как меняются журналы по мере взаимодействия с приложением. Вы можете остановить контейнер так же, как и любой другой процесс, нажав Ctrl+C.

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

$ docker run -d --env DB_URL=sqlite:///orders.db \
-v $(pwd)/orders.db:/orders/orders.db -p 8000:8000 orders:1.0

В этом случае вам нужно будет остановить контейнер с помощью команды docker stop. Сначала следует выяснить ID запущенного контейнера с помощью такой команды:

$ docker ps

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

CONTAINER ID  IMAGE       COMMAND      CREATED          STATUS...
83e6189a02ee  orders:1.0  "uvicorn...  " 7 seconds ago  Up 6 seconds

Скопируйте ID контейнера (в данном случае 83e6189a02ee) и используйте его, чтобы остановить процесс:

$ docker stop 83e6189a02ee

Это все, что нужно знать для создания и запуска контейнеров Docker. Он предоставляет гораздо больше возможностей, чем описано в этом разделе, и, если вам интересно узнать подробнее об этой технологии, прочтите книгу Docker in Practice и Docker in Action Джеффа Николоффа и Стивена Куэнзли (Manning, 2019).

ЗАПУСК ПРИЛОЖЕНИЙ С ПОМОЩЬЮ DOCKER COMPOSE

В предыдущем разделе мы запустили контейнер сервиса заказов, связав его с нашей локальной базой данных SQLite. Так можно делать при быстром тестировании, но на самом деле мы не сможем узнать, будет ли приложение работать с базой данных PostgreSQL.. Распространенная стратегия подключения контейнерных приложений к базе данных — использование Docker Compose, который позволяет запускать несколько контейнеров в общей сети, чтобы они могли взаимодействовать друг с другом. В этом разделе вы узнаете, как запустить сервис заказов с базой данных PostgreSQL с помощью docker-compose.

Чтобы использовать Docker Compose, нужно установить его. Это пакет на Python, поэтому устанавливаем его с помощью команды pip:

$ pip install docker-compose

Далее напишем файл Docker Compose — объявим ресурсы, необходимые для запуска нашего приложения.. В листинге 13.4 показан файл docker-compose для сервиса заказов. Мы используем последний формат спецификации Docker Compose версии 3.9 и объявляем два сервиса: database и api. Первый запускает официальный образ Docker от PostgreSQL, в то время как api запускает сервис заказов. Добавляем ключевое слово build, чтобы указать на контекст Docker-образа, и присваиваем ему значение… С помощью этой точки мы даем Docker Compose команду выполнить поиск файла Dockerfile и создать образ относительно текущего каталога. Под ключевым словом environment мы настраиваем переменные среды, необходимые для запуска приложений. Предоставляем порт 5432 для database, чтобы подключиться к базе данных с нашего хост-компьютера, а также порт 8000 для api, чтобы получить доступ к API. Наконец, прописываем том под названием database-data, который docker-compose будет использовать для сохранения наших данных. Это означает, что, перезапустив docker-compose, вы не потеряете свои данные.

Выполните следующую команду, чтобы запустить файл Docker Compose:

$ docker-compose up --build

Флаг --build указывает Docker Compose перестроить ваши образы, если файлы изменились. Как только веб-API будет запущен, вы сможете получить к нему доступ на http://localhost:8000/docs/orders. Если вы попробуете использовать любую из эндпоинтов, то не обнаружите таблицы. Это потому, что мы не запускали миграцию с нашей новой базой данных PostgreSQL! Чтобы запустить миграцию, откройте новое окно терминала, перейдите в папку ch13, активируйте среду pipenv и выполните следующую команду:

$ PYTHONPATH=`pwd` \
DB_URL=postgresql://postgres:postgres@localhost:5432/postgres alembic \
upgrade heads

Как только миграции будут применены, вы можете снова обратиться к эндпоинтам API, и теперь все должно сработать. Чтобы остановить docker-compose, запустите следующую команду из другого окна терминала и внутри папки ch13:

$ docker-compose down

Это все, что нужно для запуска Docker Compose. Итак, вы только что научились пользоваться одним из самых мощных инструментов автоматизации. Docker Compose часто используется для запуска интеграционных тестов и позволяет без труда выполнить серверную часть для разработчиков, работающих над клиентскими приложениями, такими как SPA.

Теперь, когда наш стек Docker готов и образы протестированы, разберемся, как помещать образы в реестр контейнеров.

ПУБЛИКАЦИЯ DOCKER-ОБРАЗОВ В РЕЕСТРЕ КОНТЕЙНЕРОВ

Чтобы развернуть Docker-образы, нам нужно сначала опубликовать их в реестре контейнеров Docker.. Реестр контейнеров — это хранилище образов Docker.. В следующей главе мы развернем наши приложения в сервисе AWS Elastic Kubernetes, поэтому опубликуем образы в ECR AWS. Хранение образов Docker в AWS упростит их развертывание в EKS.

Сначала создадим ECR-репозиторий для образов с помощью следующей команды:

$ aws ecr create-repository --repository-name coffeemesh-orders
{
    "repository": {
        "repositoryArn":
➥ "arn:aws:ecr:<aws_region>:<aws_account_id>:repository/coffeemesh-orders",
       "registryId": "876701361933",
       "repositoryName": "coffeemesh-orders",
       "repositoryUri":
➥ "<aws_account_id>.dkr.ecr.<aws_region>.amazonaws.com/coffeemesh-orders",
       "createdAt": "2021-11-16T10:08:42+00:00",
       "imageTagMutability": "MUTABLE",
       "imageScanningConfiguration": {
           "scanOnPush": false
       },
       "encryptionConfiguration": {
           "encryptionType": "AES256"
       }
    }
}

Здесь мы создаем репозиторий ECR с именем coffeemesh-orders. Результатом выполнения команды будет полезная нагрузка, описывающая репозиторий, который мы только что создали. Когда вы запустите команду, <aws_account_id> в выходной полезной нагрузке будет содержать ваш ID учетной записи AWS, а <aws_region> — ваш регион AWS по умолчанию.. Чтобы опубликовать Docker-образ в ECR, нужно пометить ее именем репозитория ECR:

$ docker tag orders:1.0 \
<aws_account_id>.dkr.ecr.<aws_region>.amazonaws.com/coffeemesh-orders:1.0

Чтобы публиковать образы в ECR, нам нужно получить учетные данные для входа в систему с помощью следующей команды:

$ aws ecr get-login-password --region <aws_region> | docker login \
--username AWS --password-stdin \
<aws_account_id>.dkr.ecr.<region>.amazonaws.com

Убедитесь, что заменили <aws_region> в этой команде на регион AWS, в котором вы создали репозиторий Docker, например eu-west-1 для Европы (Ирландия) или us-east-2 для Востока США (штат Огайо). Также замените <aws_account_id> своим ID учетной записи AWS. Ознакомьтесь с документацией AWS, чтобы узнать, как найти свой ID учетной записи AWS (http://mng.bz/Qnye).

РЕГИОНЫ AWS

Когда вы развертываете сервисы в AWS, вы делаете это в определенных регионах. У каждого региона есть ID, например eu-west-1 для Ирландии и us-east-2 для Огайо. Обновленный список регионов, доступных в AWS, смотрите по адресу http://mng.bz/XaPM.

Команда aws ecr get-login-password выдает инструкцию, которую Docker использует для входа в ECR. Теперь вы готовы опубликовать образ! Выполните следующую команду, чтобы переместить образ в ECR:

$ docker push \
<aws_account_id>.dkr.ecr.<aws_region>.amazonaws.com/coffeemesh-orders:1.0

Вуаля! Наш Docker-образ теперь находится в ECR. В следующей главе вы узнаете, как развернуть его в кластере Kubernetes в AWS.

РЕЗЮМЕ

• Docker — это контейнеризатор приложений, программное обеспечение для автоматизации развертывания приложений и управления ими в средах с поддержкой контейнеризации. Сборка Docker называется образом, который выполняется в процессах, называемых контейнерами Docker.
• Docker Compose — это платформа для оркестрации контейнеров, которая позволяет запускать несколько контейнеров одновременно, таких как базы данных и API. Использование Docker Compose — это простой и эффективный способ запустить весь ваш сервер без необходимости устанавливать и настраивать дополнительные зависимости.
• Чтобы развернуть образы Docker, мы публикуем их в реестре контейнеров.. ECR AWS — надежный и безопасный реестр контейнеров, который упрощает развертывание контейнеров в сервисах AWS.

Об авторе

Хосе Антонио Аро Перальта — консультант по программному обеспечению и архитектуре. Имея более чем десятилетний опыт работы, Хосе помогал крупным и небольшим организациям строить сложные системы, создавать микросервисные системы и обеспечивать интеграцию с помощью API. Он также является основателем компании microapis.io, предоставляющей услуги по консультированию и обучению в области программного обеспечения.. Будучи авторитетным экспертом в сфере облачных вычислений, DevOps и автоматизации программного обеспечения, Хосе регулярно выступает на международных конференциях и часто организует открытые мастер-классы.

Более подробно с книгой можно ознакомиться на сайте издательства:

» Оглавление
» Отрывок

По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 25% по купону — API

P.S. Обращаем ваше внимание на то, что у нас на сайте проходит распродажа.