MongoDB with Async Python

Name: MongoDB with Async Python
Price: 9 USD
Availability: InStock

7h 19m 54s

English

Paid

April 26, 2024

This course will teach you how to use MongoDB and document databases to build simpler and faster data-driven applications.

We start by explaining the origin and major concepts of NoSQL and document databases. You then learn how to work with MongoDB from its native shell as well as many of the CLI and GUI management tools.

Many MongoDB courses stop there. This course is meant to be a practical end-to-end coverage of MongoDB. We go beyond scratching the surface by covering real-world topics.

You'll see how to use Beanie (a popular ODM for MongoDB - think ORM for NoSQL) to map classes to MongoDB. Beanie is based on state-of-the-art Python technologies such as Pydantic and Python's async and await.

In this code-based and hands-on, demo-driven course, we will build some simple example apps using Beanie. Then we'll move on to modeling real PyPI data with 100,000s of records in MongoDB. Once we have our Python code working with the PyPI data, we'll build out a full FastAPI API around the data showing the smooth integration of Beanie and async MongoDB within FastAPI.

After we master working with MongoDB from Python, we'll turn our attention to performance. We take a large database with millions of data points and make it run hundreds of times faster than you get out-of-the-box with MongoDB. We test our performance changes with both custom Python code and the Locust load testing framework.

We wrap up the course by deploying MongoDB to production Linux servers. There are a few very important steps to getting MongoDB running in production and we'll go step-by-step through this setup.

In the end, you'll be ready to start building and running high-performance, MongoDB-backed, data-driven applications.

Watch Online MongoDB with Async Python

Join premium to watch

Go to premium

#	Title	Duration
1	Introducing the Course	00:54
2	MongoDB is Loved	03:06
3	MongoDB is fast	03:44
4	Python's asyncio	02:41
5	What is Beanie and What is an ODM?	04:28
6	Course Topics	03:44
7	Meet Your Instructor: Michael Kennedy	01:15
8	Setup Introduction	02:23
9	Installing MongoDB	02:14
10	Studio 3T GUI	01:16
11	Importing PyPI Data	02:35
12	Verifying the Data with Studio 3T	02:30
13	Document Dbs introduction	01:04
14	How Document Databases Work	03:27
15	Who uses MongoDB?	03:01
16	Mongo Shell	02:13
17	A More Complex Query	01:34
18	And Operators in Queries	01:09
19	Querying Embedded Data	01:41
20	Studio 3T: A Better Shell	02:04
21	Query Operators	02:55
22	Queries: Logical Operators	00:50
23	Queries: Projections	04:24
24	Pydantic Introduction	00:49
25	A Time of Change for Pydantic	02:12
26	Get the Plugins	01:03
27	Built on Pydantic	04:01
28	Project Setup	05:11
29	Our First Pydantic Model	06:20
30	JSON to Pydantic Converter	05:36
31	Get the Full Story on Pydantic	00:56
32	Pydantic has a Solid Foundation	01:19
33	Async introduction	01:24
34	Async for Speed	04:07
35	Async for Scalability	01:02
36	Synchronous Execution Example	04:02
37	Asynchronous Execution Example	02:21
38	Skeleton async Program	08:27
39	Full Concurrency Weather Client	07:49
40	Beanie Quickstart Intro	00:45
41	Motor, MongoDB's Async Driver	01:49
42	Beanie Quickstart: Part 1 Classes	12:23
43	Beanie Quickstart: Part 2 Connections	10:43
44	Beanie Quickstart: Part 3 Inserts	04:02
45	Beanie Quickstart: Part 4 Queries	08:43
46	Beanie Quickstart: part 5 settings	05:29
47	Lightning Review of Beanie	03:13
48	Get the Full Story of Beanie	00:41
49	Bunnet, the Synchronous Beanie	01:16
50	Modeling Introduction	00:58
51	Modeling: Relational vs. Documents	03:28
52	To Embed or not to Embed?	05:12
53	What is an Integration Database?	03:12
54	Looking for More Guidance?	00:40
55	PyPI Api Introduction	00:47
56	Recall: Importing the Data	01:03
57	Review: The Data Model	05:15
58	Creating the DB Models	08:35
59	Configuring Collections from Beanie	02:47
60	Connecting to MongoDB	04:52
61	CLI Skeleton	04:39
62	ClI REPL	01:40
63	Summary Stats	05:30
64	Recent Packages	05:05
65	Finding Packages and Releases	10:14
66	Creating a Release	07:01
67	Concurrency Safe Create Release	11:03
68	Creating Users	05:27
69	Setting the User's Password	06:45
70	FastAPI Introduction	01:24
71	FastAPI Skeleton App	06:10
72	API Endpoints Ready	08:11
73	Package Details Implementation	12:07
74	Sometimes API focused models are required	08:36
75	Stats API	03:36
76	The Home Page Doesn't Belong in the API Docs	02:01
77	Static Files: CSS	10:42
78	Introduction to DB Performance	00:48
79	Levers and Knobs of MongoDB Performance	04:38
80	Creating Indexes in the Shell	02:22
81	Our First Python to MongoDB Index	08:49
82	Releases Counted in 1ms	06:40
83	Uniqueness Index for Users	03:48
84	Projections for Packages	09:08
85	Concept: Projections in Beanie	01:11
86	Document Design from a Performance Perspective	03:52
87	Hosting Introduction	01:14
88	Don't Do What These Companies Did with MongoDB	02:09
89	MongoDB as a Service Options	02:05
90	MongoDB's Security Checklist	02:12
91	Getting the Server Ready	03:13
92	Limit Network Access with VPCs and Firewall	05:36
93	Creating an Encryption Key	01:18
94	Installing MongoDB	03:45
95	Configuring MongoDB, Part 1	04:40
96	Adding Authentication to MongoDB	04:40
97	Connecting to Production MongoDB with Python	05:44
98	Importing Data Introduction for Production MongoDB	03:06
99	Connecting to a Remote MongoDB	06:25
100	Testing our Python Code in Production	06:26
101	Final Comments on Speed	01:51
102	Load Testing Introduction	01:08
103	Introducing Locust	04:21
104	Consider a Real Server Topology	01:13
105	Running Locust for Max RPS	10:57
106	Running Locust for Max Users	09:05
107	Faster Locust Tests	01:10
108	Finish Line!	00:42
109	Git the Source Code, Again	00:30
110	Final Review	06:11
111	Stay in Touch	01:02

Course