Before we dive into the hands-on work, let’s take a moment to talk about what you’ll need to successfully follow along with this chapter.

• You should already be familiar with Python; the code is tested with Python 3.13 .
• Also, being familiar with a virtual environment or simply an isolated environment could help, but is not mandatory
• You should have your code editor already set up: whether you love VS Code, Cursor, PyCharm, Vim, or even Emacs, any editor that supports Python will work. The important thing is that you can move quickly and comfortably through your files.
• Being familiar with a command-line interface is an advantage since much of your interaction will happen in the terminal or command prompt. If you’re new to it, don’t worry—mastery comes with practice, and every step you take here deepens your understanding.
• Internet access: you’ll need it for installing dependencies, checking documentation, and occasionally...

Before diving into project setup and code, let’s clarify what this book is really about: microservices.

In recent years, the term is everywhere—conference talks, architecture diagrams, job interviews, you name it—but it’s often misunderstood.

Let’s take a moment to unpack what a microservice is, what it isn’t, and why we’re choosing this architecture for our Platform.

According to Martin Fowler from the book Patterns of Enterprise Application Architecture:

The microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API.

We can think of a microservice as an independently deployable unit of software that focuses on doing one business capability well. It runs in its own process, communicates with other services over the network...

When building complex systems, it's much easier if you have a solid approach to organizing and managing your code. This helps keep things less complicated and makes development more enjoyable.

One great advantage for developers is working with isolated and reproducible environments. These provide several benefits:

• They prevent changes to your system's main Python installation
• They ensure that dependencies stay consistent across different machines.
• They allow different projects or microservices to use their own versions of dependencies.
• They make sure tools like linters and test runners work consistently (we'll discuss this more later).

Alongside isolated environments, a proper packaging tool is how you communicate the structure, metadata, and dependencies of your microservice.

Today we rely on the PEP 621 standard (https://peps.python.org/pep-0621/) that defines pyproject.toml file as the modern, canonical way to define specifications for a Python...

When building microservices, choosing the right web framework is essential. It should be lightweight yet robust, developer-friendly yet ready.

FastAPI perfectly fits this balance. FastAPI is a modern, high-performance web framework for building APIs with Python, relying on standard Python type hints.

It is designed from the ground up to support asynchronous programming, automatic OpenAPI documentation, and rapid execution powered by Starlette and Pydantic.

In this section, you will build your first endpoint with FastAPI and explore some of the core concepts that make FastAPI not only convenient but also an ideal framework for microservice architectures.

FastAPI combines speed with an excellent developer experience. Here’s why it stands out:

• Asynchronous-first design utilizing async / await syntax
• Type hints drive validation, documentation, and support for major Integrated Development Environments (IDEs)
• Automatic generation of OpenAPI (Swagger) and ReDoc documentation...

In microservice-based architectures, managing a collection of independent, communicating services makes automated testing essential and unit tests are the first line of defense against regressions, integration bugs, and broken APIs.

They empower you to iterate with confidence, ensuring that existing behavior continues to work every time you run your code.

Why test? Here are a few good reasons:

• Validate behavior: Confirm that your endpoints return the expected results
• Detect regressions early: Prevent future changes from breaking existing logic
• Enable refactoring: Refactor code with the assurance that nothing else is affected
• Document expectations: Tests serve as executable specifications

For microservices, where interdependencies can be subtle and breaking changes potentially disastrous, maintaining a reliable suite of tests is critical, making it a wise investment to set up your test environment from the start.

Within the Python ecosystem, the pytest framework...

In coding, clarity, maintainability, and predictability are essential. When multiple developers work across many services, it's crucial that anyone can quickly understand, test, and modify the code with confidence. The simplest way to enable this is by enforcing consistent coding standards through automated tools.

This section introduces the essential tools every Python project should use: a formatter, an import sorter, a linter, and a static type checker. These tools will be added to your project as development dependencies and configured so they can be used manually, through your editor, or in a Continuous Integration (CI) pipeline.

Throughout this book, we will use Ruff for formatting, imports sorting, and linting. To add the ruff package as a development dependency, run:

uv add ruff --dev

Ruff can both check and format your code, ensuring it complies with your chosen rules. By default, the line length is set to 88 characters...

We have used uv and will use it for the rest of the book to create projects, handling dependencies, running commands, etc.

However, Python has a rich, though sometimes confusing, ecosystem of tools to manage packages and environments.

This section introduces the most commonly used ones, helping you understand where each shines and how to get started.

pip + venv

pip is the default package manager while venv is the default library to manage a virtual environment that comes with the built-in Python distribution.

Their combination is the most basic method to manage environments and packages available in every Python 3 installation. To use it, you simply need to have Python installed on your machine.

The venv module creates isolated environments, while the pip command installs packages within them. Being built-in, this approach remains a reliable option for creating simple scripts or prototyping. It provides full control and transparency since it does...

Throughout this chapter, we have explored essential concepts related to microservices, kickstarted a service using uv, and built our first FastAPI endpoint. We also examined supporting development tools and took a comprehensive look at the evolving Python package management ecosystem.

By mastering these skills, you are now equipped to streamline project setup, enhance collaboration, and avoid common dependency pitfalls—key competencies for any Python developer aiming for efficient, maintainable codebases.

With these fundamentals in place, we are ready to move forward and begin building a more interactive application that handles request parameters and cookies in the next chapter.

The definition of microservice is not unique.

• Martin Flower Microservices Guide:

  https://martinfowler.com/microservices/

For everything related to FastAPI, have a look at the official documentation:

• FastAPI Official Documentation:

  https://fastapi.tiangolo.com/

For each of the package manager tools, refer to their respective documentation link:

• uv: https://docs.astral.sh/uv/
• venv: https://docs.python.org/3/library/venv.html
• Pipenv: https://pipenv.pypa.io/en/latest/
• Poetry: https://python-poetry.org/docs/
• Hatch: https://hatch.pypa.io/latest/
• Pdm: https://pdm-project.org/en/latest/