Skip to main content
Loading Explore guides…
FastAPI Crash Course · Acedra
Home
Explore
Computer Science
FastAPI Crash Course
Sign in to save
Chat
If YouTube asks you to sign in, open the video on YouTube.
Watch on YouTube
Reload player
Transcript
109 segments
Copy
Hide video
0:00
Hey guys, welcome to my fast API crash course. Yes, we're finally going to write some code and and not just talk about AI. Uh, I mean, we'll use AI a little bit to save some typing, but I want to start getting back into the fundamental crash courses. And this one I wanted to do on fast API, which is a high performance Python framework for building well fast APIs. So, you'll be build powerful backends and microservices, things like that. Now, we're going to spend the first few
0:27
minutes just talking about what fast API offers, some of its key features, and then we're going to jump in and build an API for an issue tracker. And we're going to focus on learning the fundamentals. So, the overall architecture, creating routes, middleware, pyantic data models, swagger documentation, basically everything that's included in the fast API standard package. And everything that I show you is going to be documented and included in the description, including the full
0:53
code, the presentation document, uh even a written version of this crash course and so on. So, I hope you enjoy and let's get into it.
1:06
So, when it comes to software development, one of the most important things we do are code reviews, but it's also a super tedious task and prone to mistakes since you never really know how well someone's reviewing your code. So today's sponsor, Code Rabbit, makes code review so much easier. It's an AI powered code review tool that integrates into your development workflow by automatically reviewing your poll requests or you can even just use the CLI before you commit your code. So Code
1:33
Rabbit doesn't replace the need for code reviews. It just makes them more efficient and catches things that humans will often miss. So instead of bugging teammates with things that don't need their attention yet, you can have your code reviewed in minutes and you can catch bugs before asking a co-worker for a final review. So let's take a a quick look at this PR where code rabbit caught some bugs. So it catches that we initiated our client instance to our apprite backend in two separate
2:01
components when instead we should have created one and then used the import throughout the app. So it immediately caught this mistake and provided us with suggestions for changes that we should make. So one of the coolest features is the ability to set custom rules for you and your team. So for example, we have a rule set that describes how headings should be set in articles. And when a PR is made, Code Rabbit will catch this. Even though it's not technically a bug,
2:28
it's something that a teammate could have easily missed. So, a code rabbit will also learn from your entire codebase and help enforce patterns and and rules that you and your team set. So, it's actually pretty awesome. So, if you want to give Code Rabbit a try, make sure you check out the link in the description below. So, in 2026, I know the world has changed and I know that a lot of you are going to be using fast API and other technologies along with AI and you're going to generate a lot of
2:56
your code. However, I think it's crucial to understand uh at the very least the fundamentals of what you're using. And that goes for for anything. Uh and for my crash courses from here on out, what I want to focus on is what I think you absolutely need to know before you use any AI, before you generate any code. So in terms of fast API, that's going to be understanding the overall architecture of your API of your files and folders, creating your routes, testing them,
3:27
knowing your your data models is very important. So learning pyantic and and of course Python um and and learning type hints and so on. So that's what I'll be focusing on in this crash course. And I don't want it to be too tedious, so I'm not going to type out everything. I might use C-Pilot. I might do some copying and pasting, but I'll explain everything that's going on. So, I used to create slides, but I'm going to try this new format with these Excaladraw documents. These are really
3:55
cool, and I'll have these available for you guys to download every crash course. So, for this one, if you look in the description, you'll get this this repository which has the final code, but if you look in docs, you're going to have the Excaladraw document. Okay, it's actually a PNG version. And then you'll also have a a complete written version of the crash course with all the code snippets. So that's kind of the new format for for 2026. Moving on, I also
4:24
want to mention devsheets.io which has cheat sheets for for so many different technologies. There's one for fast API. I'll link that in the description. And it has a lot of the stuff we'll be going over and it has both the quick reference and detailed examples of of everything. All right, so enough rambling. Let's talk about what fast fast API actually is. So it's a modern high-erformance web framework that is obviously it's Python and it's built on top of the Starlet
4:55
framework or toolkit which is an ASGI framework or toolkit and ASGI stands for asynchronous server gateway interface and I'll talk more about that in a second but basically Starlet handles uh the basic web parts. So things like routing, middleware, uh request response and so on. And then fast API adds a robust layer for for building powerful APIs and also simplifying API development and just giving you a better develop uh developer experience out of the box. Now, as far as features, of
5:30
course, uh speed and performance, I mean, it's built right into the name. So it's actually on par with Node.js JS thanks to Starlet's uh ASGI environment. Now again asgi is the it's the successor to WSGI which is web server gateway interface and WSGI is synchronous and was designed for traditional web apps where each request is handled one at a time where ASGI on the other hand is asynchronous and can handle multiple requests concurrently. Now, for what we're doing, building our issue tracker,
6:04
we're going to be using a just a custom storage module with a JSON document for storage. We won't get the full advantage of this, but if you're using something like SQL Alchemy uh 2.0, something that has those asynchronous capabilities, then you'll get the, you know, that full advantage. So, in addition to being, you know, very fast, you have automatic data validation and serialization. And so it uses paidantic to um to to validate your API and it does this using Python type
6:36
hints. Okay. So basically if you send a post request with a field that's not supposed to be there, it's going to automatically strip it out. Uh and then it also adds to the next feature which is the automatic interactive documentation. So you get uh both swagger and red do bundled with the standard package and swagger is what we'll be focusing on. So it creates your documentation where it shows all your different routes uh any params or anything like that but it's
7:06
also interactive. So you can use it as you would something like postman or curl. So you can make your um your HTTP requests using swagger. uh and that includes post, put, delete, and that includes adding JSON to the body or adding custom headers, things like that. So, it's it's really powerful. And then you also have a dependency injection system. So, this makes it easy to manage components and database connections, authentication. Uh so, you can actually define
7:37
dependencies as functions and fast API will will handle their life cycle. Then you also have security utilities. So, built-in tools for things like authentication, common security practices like OOTH 2, JSON web tokens. We're not going to really focus on authentication in this crash course cuz I want to focus on just the kind of the basics, the fundamentals. But if you guys like this and uh you know, you enjoy it and it does well, then I'll move on and I'll do some more advanced
8:05
stuff. We'll look at JSON web tokens, protecting routes, and so on. Developer experience focus, so there's minimal boilerplate. Everything is explicit and readable. It leverages Python type hints. And then you also have support for websockets and streaming so you can build real-time applications and so on. So I'm not great at creating diagrams, but I wanted to kind of give you guys just a a very highlevel overview of of just how all this stuff works. So basically, you know, we have our front
8:37
end, right? So, we have our client, that could be React, that could be Vue, that could be a mobile app, a desktop app, whatever it might be, that makes an HTTP request to our server that's running fast API. And usually you're going to have, you know, EngineX there as kind of your entry point using a proxy. Um, you might have some static files. And then Fast API is running with this ASGI um server, which would be like uvicorn or something like that. Uh and then of
9:06
course you're going to make an HTTP request along with a specific method and route. So let's say we make a get request to API v1 issues. That's going to fetch all the issues. So that that will interact with your data whether that's a you know postgres database or or even just a JSON document like we're using. Uh and then it's going to fetch that data. Now on top of that you're going to have your paidantic models. So, we're going to have some issue models or issue schemas with certain fields and
9:36
that's where our validation comes in and that's all based on Python type hints which is really cool. And then of course in addition you have your interactive documentation for testing. So we can test all these routes using swagger and uh you know we can attach form data or JSON data. And that's pretty much uh just a basic overview, very highlevel overview of how all this works. And if that's confusing, it'll make more sense as we move along. All right, so let's
10:07
jump in now and let's create our issue tracker API. All right, so we're going to get started. And I'm assuming that you guys have basic Python experience. So I'm not going to explain basic Python syntax or how to install it or anything like that. Um, so if you if you're not familiar with Python, I would suggest watching my my crash course or just anybody's basic uh Python tutorial. So the first thing we want to do is just just create an empty folder. I called mine fast API issue tracker and then
10:37
open it in your ter not your terminal, but open it in your text editor or your IDE as well as your terminal. So I'm using VS Code's integrated terminal and we want to create uh what's called a virtual environment and this is so when we install our dependencies everything gets installed it's it's localized in this project in this folder rather than global. So what we can do is run python-m venv and thenvev for the folder name and that will create this.veenv folder that you see here on the left.
11:08
All right. Now we want to activate this virtual environment and we can do that on a Mac with source and then we want to go dot slash.vev and then bin and then activate. So if I run that now you can see we have this parentheses with the folder name so we know it's activated. Now if you're on Windows it's a bit different. You want to do uh dot slash.ve slashscripts slash and then activate. Okay. Okay. So, if you're on Windows, run that and and that should activate
11:41
your environment. All right. Now, what we want to do is create an entry point. So, we're going to call this main.py. And I know a lot of people that watch my videos are JavaScript developers. So, I'll be doing some comparison with Node.js and Express because that is, you know, that's what you would use for a lot of the same stuff. Um, so in Node and Express, you would have your server.js or app.js and you would initialize express there. We're doing the same exact thing here. So, um,
12:10
before we can initialize it though, we of course need to install it. So, basically, I'm just going to use this dev sheets.io for some reference. And you can install uh fast API a couple different ways. You can use the all extra and that includes a bunch of different dependencies or you can use the standard which includes just the things we we want that we're going to need like paidantic and swagger and so on. Um you can do it this way. So install fast API and then u which is the
12:41
the ASGI server standard or you can simply just do fast API with the standard extra which is what I'm going to do. So let's jump into the terminal here and let's say pip which is the Python package manager install and then in double quotes I'm going to say fast API and then in brackets we'll use um standard. Okay. And that'll install it locally. It's not installing anything globally on your machine because we're in a virtual environment. All right. So, now that
13:13
we've done that, we can import, let's say from fast API, we want to import uppercase F fast API. Okay. And then we can initialize that. And I'm going to be using Copilot to do my autocomplete just so I don't have to type everything out. So we're just initializing fast API setting it into this app variable and then that's really all we have to do. We can now actually start creating routes. So we can do that with a decorator like this. So we use this at symbol and then the app variable
13:47
and then dot whatever method we want to accept for this route. So in this case a get request and then you would add your URL or your endpoint here. So this would be just the home route uh or home endpoint. I'm actually going to create a health endpoint so that we can just see if the API is up and running. And then what you would do is under that decorator is create the function. So we're going to define a function. This doesn't have to be async for for what
14:13
we're doing. Um define a function called health check or whatever you want to call it. The name of this function is irrelevant. And then we're just going to simply return uh a dictionary which will then get serialized into uh uh JSON. So we'll just say status. Okay. And that's it. We should be able to run our server with uicorn. And there's actually a wrapper that we can use to do that with fast API dev and then the name of the file. So main.py. And now our server is
14:43
running. So that's it. Just a couple lines of code. Run our server. And now it's running on localhost 8000. Now if I go to just the home route, it's it says not found because we didn't create that route yet. But if we go to health, then we see status. Okay. Now, this isn't really how you want to how you want to test your routes. You could use a tool like Postman or curl, but remember fast API has interactive documentation with swagger, which is really cool. So, we
15:13
can just go to localhost 8000/doccks and we can use swagger. Okay. Any route we create just by adding that decorator uh we're going to see here. So we see our get request to /halth. It's going to show us what the response should look like, the code, uh any parameters, but you can also try it out. You can also hit that route from here. So I'm going to hit execute. And now it sends a request. We get the response 200 response status. Okay. And then we get our headers. We get a curl command if
15:45
you want that. Um so it's pretty cool stuff. And this is what we'll use to test. So that's how we can create a route. Um I do want to show you show you some other simple routes before we move on to our issue tracker. So let's say we want to just have some items. So I'm going to just add here let's say items. We'll set that to a list or an array. And let's just have one, two, and three. Okay. Now I want to have a route that will fetch these items and display them.
16:18
So let's come down here. We'll say app.get get items and then create a function. Doesn't matter what the function's called. Get items is fine. Typically in Python, you're going to use the the underscore syntax. Uh and then we'll return items. And now just by doing that, if we go back to the browser here and refresh, now we see get items, right? And if I do try it out, I execute now we can see it's fetching those items. All right. Now let's say we wanted to get uh a single item by its
16:52
ID. So we can do that as well. So let's come down here. Let's say at at app get items and then notice I have slash and then curly braces item ID. Okay. So this is a path param and and you can check out again dev sheets has this stuff. So right here path params. So we pass in the item ID and then what we do is create a function. doesn't have to be asynchronous in this case. And then we pass in that item ID and we add a type hint. This is in this case it's it's an
17:25
int. And then we'll return that. So let's do that here. So app.get items ID. Create our function that also takes in an item ID. And then as far as the logic, we're just looping over the items, checking if the ID matches whatever's in the URL. Return that item. And if it's not there, then return an error. All right, so let's go ahead and save that. And then we'll go back to swagger and let's refresh. And now you'll see we have that route right here. Item slash item ID. And notice now
17:57
it it has an input. I can't click in this yet. I have to click try it out first. And then I can add the ID. Execute. And now it gives me item one. And if I were to put something that doesn't exist, like let's say 100, then I'm going to get that item not found. So creating routes is is very simple. Now, if you wanted a query string like let's say you wanted I'm just going to type it up here. So like slash items and then maybe question mark page equals 1 and uh
18:28
I don't know limit equals 10. So if you wanted to do that, you wanted to get these values, I'll just show you on the on the dev sheets here. If you go to query parameters, you would just pass those in. This one says skip. I put page, but whatever it is, you would put it in here. You would uh add the the type hint. So, int and then set the value uh default value. And then you could access that in here, right? So, if I put limit equals 10, pass in limit here, and then I could access it. All
18:59
right? So now let's take a look at uh a simple post request before we jump into our our actual issues routes for our API. So I'm just going to add down here app.post items and then create an item. And you could pass in the individual fields like what do we have I think well just a name really. Uh or you could pass in the entire item as a dictionary which is what we're doing here. And then we're just simply appending that new item onto that dictionary and then returning it.
19:30
So let's try that. I'll save it. We'll jump back over to Swagger and let's see. We should have a post route. Did I save this? So app post refresh. There it is. Okay. So then the post request is green. And then you'll see here we have an input for our item. It just has this additional prop one just as a just a generic field. But let's say try it out. And we'll get rid of this and set this to let's say this has a name and test item. We'll execute send the post request and then we get
20:08
that that object back. Name test item. Now since we don't have any models set up, we have no schema. We didn't set up paidantic yet. I can send anything here, right? Like I could just send foo and then for a value bar and execute and that sends and then it responds with name and that fu fuar value. Okay. When you add a when you create schemas with with paidantic you can validate this right? So you can only send certain things otherwise it'll get stripped out.
20:43
Same thing with the response. You can send set a model for what you get back in the response. And we'll get to to to models soon. But what I want to do now is show you how you can use the router because you're not going to want to put all your routes in the the main entry point here. In fact, we can get rid of all this item stuff. You can keep the health check if you want. I'm just going to get rid of it. Um, and I'm also going to get rid of the items. And now we're
21:07
going to start to create our issue routes. Now I'm going to put this in a separate file. So, in the root here, I'm actually going to create a folder called app. And then in app, I'm going to have uh a folder. Let's create a folder called routes. And then in routes, we're going to have a file called issues.py. And this is where any routes that have to do with issues are going to go. Now, in order to do this, to use a separate file, we need to use the the API router,
21:36
which again, if you're coming from Node and Express, it's very similar to how the express router works. So, we're going to bring that in. Let's say import or not import, let's say from fast API. We want to import API router. And then we're going to initialize it into a variable called router. And then when we want to create routes, we then use the at@ routouter decorator. Instead of doing at app.get or post or whatever, we do router.get or post. Now, we could do
22:08
it this way and just have slash issues, but a better way to do this would be to add a prefix in here of issues and then we don't have to add it in each row like that. Okay. And then tags. What that's just going to help the documentation. So when we when we view our swagger UI, it'll be separated by the different resources, issues, users, etc. Um, and also for prefix, I usually like to do slash API slash issues at least. And sometimes you can do like the version.
22:38
So I'm going to put v1 in there. So we know that this is version one of the API. And then if you if you update it and a lot of things change, you can then have a version two, version three, etc. All right. Now, for this get, let's go ahead and create a function. So, we'll just have get issues. And then, as far as what I want to return, we don't need all this. Let's just return an empty array for now. Okay. And we don't have um our our JSON file yet. So, we don't
23:07
have any data. So, we'll just have an empty uh empty list or empty array. Okay. Now, we should well, we shouldn't see this just yet. As you can see, if I refresh swagger, it doesn't show up because we need to wire it up in our main.py, which is very simple. It's just two lines. So, one is going to be the import where we can say from app.routs.us import router as issues router. And then down here, we simply say app.incclude router and pass in that issues router.
23:38
Now if you had like let's say users and you had a users route you would do the same thing except you would replace issues here and here with users and you would pass the users router in down here as well. So now if we go back to swagger and I refresh now we can see issues and we can make a request here which it'll just give us just an empty array. Okay. Okay. So, now that we have that set up, we can move on to our storage, right? Because we want to be able to store uh
24:07
issues in a in a JSON file. So, let's come back to VS Code. And I'm going to put this in a file in the app folder called storage.py. And basically, this is just going to have two functions. One to load data from the JSON file and one to save data. Now in a production project again you'd probably be using something like SQL model or SQL alchemy or or some kind of OM like that along with uh like a Postgres database but I wanted to keep this focused on fast API and not
24:41
introduce too much extra stuff. So and this will be pretty simple. So I just want to have a couple imports here. We want uh Path Lib from Pathlib. We're importing path. And I'm just going to shut off for a couple minutes. I'm going to shut off um Copilot just so we can type all this out without confusion. And then since we're using JSON, we'll use the JSON library. All right. And we don't have to install anything extra for this. So I'm going to define both the
25:10
data directory and the data file that we're using. So data directory, I'm going to set that to path and it's going to be a directory called data. So it'll be just in the root. And we don't have to create this. So it'll be created automatically when we insert or when we create uh a new issue. And then data let's say data file. So data file should be data directory slash and then the name of the file which is going to be issues.json. Okay. So basically I if you were to keep
25:44
it like this and you stick with JSON files how the way we're doing it you'd have a separate JSON file for each resource like maybe users.json. JSON, post.json, etc. All right, so now let's create we're going to define a load data function. All right, and this is going to be pretty simple. We're just going to first off check to see if the data file exists. So let's say if the data file dot exists, then we want to open it. So let's say with open uh we want to open data file and we want
26:25
we're just reading it. So we're going to pass in r for read and then as f and then what we want to do is get the content from it. So let's have a a variable called content and let's set that to uh the file dot and we'll use the read method. All right. And then I just want to strip out any white space. So we can do that by saying if content dot strip then we want to return the JSON dot and then we'll use loads and pass in content. So that's it's just simply
27:02
looking at the file reading it returning the the JSON and if it doesn't exist so let's go right here and let's say return just an empty array. So pretty simple that's our load data. Now let's create our save data. So save data and that's going to take in data. And what we want to do here is first off let's let's create the directory the data directory if it doesn't exist. So we can do that with data durd and we can pass in here let's say parents equals true and let's say ex uh
27:43
exists. Okay, set that to true. So it's just it's just going to create it if it's not there. Then we want to open it to write to. So let's say with open and pass in our data file and we're going to pass in W here because we want to write to it. And we'll say as f. Okay. Then we just want to use JSON.dump to write to it. and pass in here the data, the file, and the options, which I'm going to set indent to two just to make it a little prettier. And that's it. That's our entire storage module to
28:22
to load data from the JSON file and to to save it. Okay, we can close that up. Now, we can go back to our routes and start to um start to work with that. So, let's go to issues and let's see. We want to bring in uh couple things. Oh, you know what? Before we do this, let's set up our schemas. I didn't realize we didn't do that yet. Um, so in app, we're going to create a file called schemas.j um js. You can tell what my main language is. So, schemas.py. And basically what this allows us to do
28:59
is use paidantic to map out data for issues or or any resource in specific situations. So when we make a post request, we send in the body an issue with a title uh a description, a priority. So we want to create a schema for creating an issue. When we do an update, we also send in specific data. We want to create that schema. But when we get an issue back from our API in a response, we want a schema for that as well. Also, I want to have some enum um enums for the status and the priority
29:35
because they need to be specific values. For instance, a status should be like open um in progress or closed. It shouldn't be able to be anything else. So, we're just setting strict rules for our data for issues. So let's bring in since we're using enum we're going to say from enum import enum from paidantic we want to bring in base model. So basically to create these schemas it inherits this class this base model. And then we're also going to bring in field from paidantic which
30:08
allows us to um to add validation constraints like like min length and max length things like that. And then from typing, I'm going to import optional because we're going to have some optional fields specifically for the update. Okay. So, now that we've brought that stuff in, let's let's work on our enum. So, issue status, that's actually exactly what I want, except I I don't like to use caps here. It's up to you. You can if you want, but I just want to use lowercase. So basically we're saying
30:38
that the status okay when we assign this to the the status of the issue it has to be one of these and then we'll do the same with priority. So let's say class uh issue priority and all we're we're using enum and we're saying it's these are also strings. So priority has to be low, medium or high. It can't be critical or or anything else. If you want it to be able to be critical, then you would add it here. So now, now that we have those uh enum classes, let's go ahead and create a
31:16
schema for creating an issue. So when you make a post request, that data that you send in the body. So we'll say class, and I'm going to call this issue create, which takes in a base model. And I just want to type this stuff out because it can be a little confusing uh using C-pilot with big blocks of code like this. So I'll just snooze it for a little bit. And we're going to have a title which is going to be a string. Set that to field. Remember field allows us
31:45
to add validation constraints such as min uh min length which I'll set to three. And let's say max max length we'll set 100 for the for the title. And then let's do description. And if you want to change any of these values, of course you can. Whoops. Description. Um we're going to set that yeah to string and then to field. So field let's set min length to five and we'll say max max length to I don't know th00and and then let's do the priority. So priority is going to be the the enum
32:36
class which is issue priority and then we'll set that to issue priority domedium. Okay? Because we can set it to any of these here. Low, medium, high. So, I'm just setting it to medium by default. So, that's that's what the schema looks like to create an issue. Now, notice I don't have status in here because status is going to be hardcoded as open when we create an issue. Now, let's do the update, which is going to be a bit different. So, let's say issue update and base model. And then we have
33:14
the title. So title. Now I'm going to set this. This is where this optional comes in that we brought in. Spell that right. Optional. Uh and it's going to be an optional string. Now the reason it's optional is because when you do an update, let's say we just want to update the title. We don't want the description to be required, right? Because we don't care about updating the description. So when we make that put request, everything's going to be optional because you you might only want to do
33:46
one or two things. So let's set this to field and we'll set let's say default to none. And if you're new to Python, you can think of none as like null from other from like JavaScript just means empty. And then let's do max length of what do we do? 100. And then let's do description. So description, same thing. It's going to be optional and it's going to be str. Set that to field. Set the default equal to none. And then let's do max uh max length of what do we want to do here? I think a th00and.
34:31
Okay. And then we'll have a priority. So priority is going to be set to optional as well. However, it's also going to be issue priority and we'll set that directly to none by default. And then we have status. Status is going to be optional. Um issue status and set that to none. Okay. So that's the schema for updating an issue. Now the last thing I want to add here is the schema for the the response the output. when you fetch either um you know all issues or just a
35:08
single issue it's it needs a schema. So let's call this one. We'll say class issue out and inherits base model. It's going to have an ID which is going to be a string. It's going to have title string description string and then also priority basically all the fields. priority which is going to be issue priority and then status which will be issue status. And that's it. That's that's all of our scheme is. Again, we have our enums for status and priority. We have our what
35:55
the issue should look like on a create, what the issue should look like on an update, and what it should look like on output or response. So, the next thing we want to do is move back over to uh to our routes, right? Issues.py. And couple things that we want to bring in here. Since we're not using a database, we need to create our own ids. So, I'm going to use uuid for that. And then from fast API, a couple other things we want to bring in. I want HTTP exception and status. So that'll allow
36:30
us to um to set you know we'll set a 404 if it's not found things like that. And then we also want to bring in from apps schemas let's see we want to bring in yeah issue create issue out and issue update. And then we also want to use our storage modules. So let's say app.sto storage. We want to import our two functions which are load data and save data. So those are all the imports. Next, let's uh see. So we'll go ahead and and finish this route. Right now, it's just returning an empty list. So
37:10
I'm going to add going to add a dock string here. Just say retrieve all issues. We're going to set a variable of issues to to load data and then return those issues. Let's get rid of this. And then one thing I forgot here is we're also going to pass into the get a response model. And this is going to be what this abides by, what we return, which is going to be a list, right? Because ultimately it's a JSON array. In Python, it returns a list. And it's going to use the issue out schema. Okay?
37:41
So again, which is going to be this this stuff here. So each route that we create, we'll also assign a response model to. Now, let's do the post request so we can actually create an issue and it will create the the JSON file. So, I'm going to say at@ routouter.post and I'm going to use uh copilot here just to save some time. There's going to be a couple things I might change up, but basically we're just making a post to slash which in reality is API v1 issues. And then the model here is just
38:11
issue out because this is not a list. This is this returns a single issue. You add it and then it returns it. This up here returns multiple issues. That's why it's a list with the issue out schema. This we just add the schema. And then we can also add a status code. And in this case, we're changing it to 2011. So this static object can have these different constants that represent different status codes, 404, etc. All right. Then we're going to add the function. Whoops.
38:41
We're going to add the function to create an issue. Okay. that takes in issue and the schema of issue create. And then let's see, we don't need to wrap this stuff in issue out. It'll do that automatically. So, we can actually get rid of this and just make this a dictionary. So, add that. And then we need to add our double quotes. Yeah. So, we just add double quotes. And for the ID, it's going to create a UU ID. title is coming from uh right here. So, you know what? I
39:18
think in the in the final code I called this payload. So, let's let's actually change that to payload. And then change these to payload as well. Yeah. So, yeah, the payload is is coming from the body of the request. Setting the ID, title, description, status. Notice how we're setting it to issue status.open, open, not simply just a string of open. And then we're appending that new issue to the issues from the JSON file. And then we're just saving all of them with
39:52
the new one. And then finally returning the new one, which is going to uh you know abide by this issue out schema. So that should work. Let's try it out. We'll save that and let's refresh. We should see our post request here. And I'm going to say try it out. And title I'll just say issue one. And uh let's see description I'll say this is a test issue and medium for the priority. Let's execute. And there we go. So we get a 2011 because we remember we did that status
40:29
whatever that constant was. And then we get our ID, we get our title, description, priority, status is open. So yeah. So, and that should have created, let's check it out. So, you can see now there's a data folder with an issues.json with that that object in it, that issue in it. All right. So, that's working good. So, now we just want to finish up this this CRUD layer, right? We want to be able to to create, update, and and do all that stuff. So, let's see. Let's do a single issue, though,
41:03
before we do any update or delete. So I'm going to say at routouter get take in the issue id the response model since this is returning a single issue response model is going to be issue out and then let's create the function. So let's say uh defaf get issue and this should be fine. So getting the issues from the data looping through finding the the right ID if it's there we return it. If not, we're going to raise an HTTP exception. This is something we brought
41:39
in from fast API. And then adding the status of 404. We're using um status dot and then that constant. And if it's not there, you can have this as an error message. Okay. So, we'll save that and then let's try it out. I'm going to come back here. Let's refresh. And I'm going to copy uh let's try it with an ID that doesn't exist first. like we'll do 100 execute and we get issue not found for the detail for the error and then let's copy an actual ID that works from this response.
42:20
Uh actually, you know what? Let's add another one. Before I do that, I just want to show you if we make a post request. See, try it out. and let's say issue two and for the description I'll say this is another test and then I want to show you if I add in something here that's not in the schema right so again if I do foo foo bar like I did earlier without using any schemas and we go ahead and execute so it it goes through but what it does is it just strips out and ignores this
43:04
because that's not in the schema. All right, but now we should have two issues. So if I come back up to the get and execute, now I see issue one and issue two. So let's copy the issue two ID. Let's go down to the single that we just created and let's add that here and then execute. And now you can see it shows me issue two. All right, so that's that. Now let's do the the update the put. So I'm going to open go back to my issues.py and let's say at routouter.put. We want to take in
43:39
the ID the response model. It's just going to be issue out. Then we have our function. Uh let me see if this looks good. So we're getting the issues from load data. Looping through checking the ID copying the issue putting it into a variable. I think I did this a little bit different in the final repo, but not much. And then we're checking for the title description because it can be it can be none. Um, if it's not none, it's going to get set to whatever that
44:10
payload was for all of these. All right, then we're going to save it to the file. If it's not there, then we raise an exception. Good. Let's save that. And then let's try to update one of these. So, I'll refresh and let's grab an ID. So, I'm going to execute. Get get one of these IDs. I'll just grab the first one. All right. And then we're going to come down to the put, which is orange. Try it out. I'm going to put the ID in there. And then I only want to change the
44:43
description. So, what I'm going to do is get rid of this other stuff. And remember, it's optional with the the issue update schema. So, I'll say this is the updated issue. Execute. And we get back uh 402. That's because I have a trailing comma. Let's get rid of that. Execute. There we go. So, now the description is this is the updated issue. And if we were to go up here and make this request to get all the issues, you can see one has that updated description.
45:16
Okay. Okay. And then the last thing we want to do is the delete. Let's just um let's just create another one to delete. So we'll go to post. Try it out. And I'll just leave this stuff here. Just string string whatever. Execute. And now we have our third. And I'm just going to grab that ID. Okay. So grab that ID. And if we were to fetch all of them, there should be three now. So that's the third one. Now let's go back and let's add the delete. So let's say at routouter.delete.
45:54
And we want to return a 204 which is no content because we're deleting it. We're not going to return it. And then let's see. We have our delete issue. It's going to get from the JSON file. It's going to loop through. it's going to pop off the end um or pop off wherever the index is, whichever one we're deleting and then raise an exception if it's not there. So, very simple. And then let's come back over and let's try to delete. So, delete is red. So, now I'm going to say try it out. Put pop
46:27
the ID in there. Execute. We get back a 204. Um,
46:38
we get a validation error. Um, let me see if see if that actually deleted. Execute. And yeah. Okay. So, it did delete. We have two. All right. So, now we have full CRUD. So, we have full H full CRUD API. Now there's a few other things that I want to show you. I want to show you uh how to add middleware. So every framework has or every backend framework just about has the concept of middleware which is really just a a function or code that runs before or after each
47:20
request and you have access to that request and response object and you can do things with it. So a lot of authentication will have middleware logging things like that. So, I figured what we could do is just create a simple piece of custom middleware. So, we're going to have a timer uh that basically will get the the timing of the request and it will send that as a custom header with the response. So, we could put it right in the main.py, but I figure we'll
47:51
in the app folder, we'll create a folder called middleware. That's what you would do in a, you know, a larger project. And in middleware, let's create a file. And we'll call this timer.py. Okay. And I'm just going to mute gonna snooze copilot for this just because I don't want it to confuse you guys. So let's import time and let's import or let's say from fast API I want to import request because we have access to that request object and we want to use that. Um, and
48:28
we also want to send uh we want to attach a custom header to the response as well. So this is actually going to be an async function because there's a a specific function that we call called next that is asynchronous. So let's say async define a timing timing middleware and you can call this whatever you want. The name of the function doesn't matter. And then it's going to take in request which we'll set to request. And then it's also going to take in that call next function.
49:07
And then in the function body let's create a variable called start. We're going to set that to time doperf counter. And I'll explain this in a minute. And then let's say um response we want to set that to await. And then call next. and call next will take in the request. Then I want to set the custom header. So we can take the response object and we can say dot header or headers and then in brackets we can call this what we want. I'm going to call it x. It's
49:41
typical convention to just do x dash. So we'll do x dash process dash time. And then let's set that to an string. And in that string, I want to add um some dynamic code here. So, we're going to take our time.perf counter. And then from that, we want to subtract the start. And then I want to do four decimal places. So, we can format that with colon and then period 4. So, four and then f. And I want to put an s at the end because it's however many, you know seconds.
50:19
um and and actually that s should go inside the quote and then I simply want to return that response. Okay, so uh again just to kind of go over this, we have our request that gets passed in. Call next, which just means call the next piece of middleware. If you're coming from Nodeen Express, it's very similar to the next function. And then um this right here, time perf counter. This is a high resolution counter to measure the elapse time. And what we're doing here setting the custom
50:52
header to uh a calculation which is the time taken to process the request and then we just add it as a custom header and we return the the entire response. Now to use this we need to wire this up in main.py. So let's go there and then we're going to bring in let's say from app dot app.middware.timing timing. We want to import our timer. Uh, what did I call it? Timer. Timing middleware. That's what I called it, right? Timing middleware. Yeah. Why isn't it could not be resolved? Um,
51:41
middleware. Oh, timer. timer is the name of the file. All right. And then all we need to do after that, let's go right under where we initialize our app and let's say app. Middleware. And then we want to pass in here http. And then we want to open another set. And this is where we add the name of our function which is going to be timing middleware. All right. So now to test it, we can just go to Swagger and just make a request. Let's say let's use this get request. Let's say try it out. Execute.
52:19
And then what we should see down here is the X process time. All right. So we we added this custom header there. So 0.0019 seconds. If I go ahead and try this again, let's execute. Now it's 0012. Okay. Okay. So, it's just giving me that that response time. So, very very simple, but I figured that it's a you know, it's a good way to show you guys how to uh how to implement middleware. Now, another thing I want to look at is cores. So, or cross origin cross origin resource sharing. Because
52:58
right now if you were to use this API and deploy it if you try to use it with a different domain in the front end like let's say this is at I don't know um issue tracker.com or whatever or.io and then you have I don't know myiss issues.com as your front end your reactor or view or whatever and you try to make a request you're going to get a cause error in the in the browser console. So if you wanted to to open it up, you could use the the cores middleware. So to do that in main.py,
53:32
we can say from from fast API um actually yeah we want to do from fast API middleware.cores import this cores middleware and then we'll go right after our custom middleware and let's say app.add add middleware and then coores middleware and then you can add your origins your different values here. Okay, so what we're doing is allowing all right we're allowing all origins which means we're allowing all domains to access this API. So if this was public and you wanted just anyone to
54:11
access it then you would do this right it was saying also all methods and all headers HTTP methods and headers are allowed as well. Um, if you wanted just specific domains, then you could add that into this list here. But as it is now, it's it's just public and open. So, I'm just going to keep it like this. All right. So, yeah. I mean, that that's kind of all I wanted to go over. I don't want this video to be too too long. Uh, I do want to do a deployment, though.
54:39
So, what I would suggest is render.com. If you're not really good with DevOps and you you don't know Docker and you know, you don't really know AWS or platforms like Digital Ocean, Render is great because it does all that stuff for you. And basically, you can just link up your your GitHub repo and and they're not sponsoring this or anything. They've never sponsored me. It's just a service that I really like and I think is great, especially for beginners. So, or just
55:07
people that aren't into DevOps. So, what we're going to do first before we even go to render is go into the terminal here. And I'm just going to stop I'm just going to stop the API. Um, and and we want to generate a requirements.ext file. So basically this just has all the dependencies that are required for this project which are you know fast API pyantic swagger all the stuff that was installed with that standard extra that standard package. Um it's kind of like u
55:42
like a package.json if you're if you're coming from node express. So we can do this with pip freeze and then uh we want to do requirements.txt txt. Okay. So, that'll generate it. Now, you can see we have that file and it it just has everything that that is in this this project. All right. Now, once we do that, we want to you want to push your code to GitHub. Now, I'm not going to do that because I already have a repo on GitHub with this pretty much the same
56:15
thing that we just created. So, I'm just going to use that. So, let's go to render.com. And you want to just log in. And I believe you can just log in with GitHub. Uh, and then we want to create a new web service. And then yeah, so my my repos right here, fast API issue tracker. I'm going to go ahead and select that. And then let's see this stuff. We can leave. Um, what we do want to add is in the build command right here. Actually, it's already there. pip install record. So
56:53
what this does is it'll just install those those packages those dependencies that are in that requirements. And then for the the start command we're going to use uicorn. So let's say uicorn um main colon app and then you add your host. So d-host which is local. So 0000 and then d-port and just the port variable. So, money sign uppercase port. So, that should be the the star command by default. And then that should do it. We can click on the free package. So, you don't have to
57:31
pay for this. And then if you had environment variables, which we don't, you would put them in here. So, let's say deploy web service. And then that's probably going to take a couple minutes to to deploy. You'll see your logs here. So it's going through and it's installing all of our packages, all the dependencies. And then this will be your URL. So right here for me, it's going to be fast apiissue tracker.on.com. And I can copy that. Actually, we'll just open in a new tab. And it says not
58:06
found because obviously it's not it's not done deploying, but we'll test that in a second. All right. So it says build successful. Okay. Okay, so it says available at your primary URL. Let's go back here and let's refresh. We get not found, which is which is fine because this is the the home endpoint, right? The index. So we want to go to slash um what do we want to go to? Let's say API slashv1 issues and we have an empty array. Now we can make a post request. Actually we should be able to use
58:42
can we use docs here? Yeah. So, we're on the production domain and and you don't have to deploy with the docs, but I just want to be able to test this. So, let's come down here and let's say try it out and issue one test execute. Okay, there it is. Good. Now, if I go back to my domain, see API slashv1 issues. And there we go. All right. So, our API is now live. So, you could now create a front end, excuse me, and link to it. Obviously, you'd want to add authentication. I mean, this is just an
59:31
example to give you the fundamentals, but that's it. Let me know if you guys like this and if you want to do more with fast API, I'd be happy to, you know, to look into authentication and to um use JSON web tokens. In fact, in the final repo, if you look at docs and you look at the crash course, the written version, I do include authentication. So, if we go all the way down cores, that's what we left off with. Let's see. Yeah. So, right here. So this shows you
1:00:05
how to add your your O schemas. So your token token data user and proceed with JSON web tokens. All right. So that's it guys. Thank you so much. If you like this, please leave a like and I will see you in the next
Here to help you learn
Sign in to keep a private conversation with your course tutor.
Ask me anything about the material…
Sign in to chat