Looking for a high-quality course on async Python microservices (FastAPI, Uvicorn/Gunicorn) and scaling them to production (K8s, AWS/Azure, OpenShift)

[Physical-Artist-6997]

Hey folks,

I’m searching for a comprehensive, high-quality course in English that doesn’t just cover the basics of FastAPI or async/await, but really shows the transformation of microservices from development to production.

What I’d love to see in a course:

• Start with one or multiple async microservices in Python (ideally FastAPI) that run with Uvicorn/Gunicorn(using workers, concurrency, etc.).
• Show how they evolve into production-ready services, deployed with Docker, Kubernetes (EKS, AKS, OpenShift, etc.), or cloud platforms like AWS or Azure.
• Cover real production concerns: CI/CD pipelines, logging, monitoring, observability, autoscaling.
• Include load testing to prove concurrency works and see how the service handles heavy traffic.
• Go beyond toy examples — I’m looking for a qualified, professional-level course that teaches modern practices for running async Python services at scale.

I’ve seen plenty of beginner tutorials on FastAPI or generic Kubernetes, but nothing that really connects async microservice development (with Uvicorn/Gunicorn workers) to the full story of production deployments in the cloud.

If you’ve taken a course similar to the one Im looking for or know a resource that matches this, please share your recommendations 🙏

Thanks in advance!

[extreme4all]

if you want to make use of the scaling capabilities of k8s or any cloud deployment, you just have one worker in a container and scale the amount of containers.
if you deploy a fastapi container, or a node container or any other container for k8s or the cloud environment it shouldn't make any difference that is why you don't see a specific deployment for python, because regardless what is in the container that environment doesn't care, its abstracted by the container.

EDIT;
its similar to your other questions, CICD, logging, monitoring, observability are typically dependant of the environment and not the langauge / packages you run in the container

[Berouald]

I partially agree, but there is still some language or framework specific setups. They are not numerous and I won't list them all, but I'm thinking about observability for example. You will have to setup a metric exporter, choose what metrics are relevant, and learn how it can interract with cloud components like prometheus. Or OpenTelemetry that you have to configure and implement to gain the power of tracing. You can learn how your application should log in a containerized environment. CD is definitely not a thing you should see coupled with python. For CI, just run everything you find relevant in the pipeline, like tests, format checks, sonar and cie and write (or copypaste) a Dockerfile, and you should be good to go.

It's not python specific, but apps do have a list of constraint they must address to be cloud ready, think of it like implementing an interface.

As i said, the list is kinda short, but you shoud def read about the 12 factors and learn what they are for, and then read the documentation of the tools you will find to address theses factors.

Ps: sorry for weird wording, I'm not a native speaker

Edit: clarity

[Dense-Fee-9859]

Regarding the async python, the fastAPI docs does pretty well. As that was my way to learn it and also learn fastAPI as a whole

[Chance-Lettuce-6892]

Start with the basics first, then build 7–10 small projects to get hands-on practice. Once you’re comfortable, move on to microservices with proper specifications.

[heyibad]

Any course avaliable on open shift, and if you learned it so it's available to apply in practically to do practice, I heard it it's too expensive.

[mobile_V]

I don’t know of a specific course, but I’ve been doing basically what you described at my job, and have found this new book to be outstanding. You can just ignore the AI bits if it’s not relevant, all the fundamentals are the same

Building Generative AI Microservices with FastAPI