-: In the last section, we had a quick discussion
about load balancers,
and we discussed why they're not quite appropriate
for our application.
In this section,
we're gonna move forward and talk about ingresses,
this is a type of service that is going to
eventually get some amount of traffic into our application
and allow our outside users to access all the different pods
that are running containers that they need to get at
to actually access our app.
All right, so quick diagram here.
So as you might guess, yep, traffic's gonna come in,
it's gonna hit this thing called an ingress,
and then it's going to be sent off or routed off,
to either our client set of pods or the server set of pods.
Now, in the world of Kubernetes,
there are several different implementations of an ingress.
We are going to be using a very specific implementation
called an Nginx ingress.
Now, before we talk about exactly
what this Nginx ingress is, how it works,
all that kind of stuff
I wanna have a very important discussion with you,
really critical that you pay attention to this,
because if you don't,
it's gonna make things really really confusing
when you go and start to look up documentation.
So here's the very important note,
the very important thing you gotta understand,
so you and I are going to be using a project
called ingress-nginx, that's the name of the project.
This is a community-led project, and by community-led,
I mean that it is a part of
the official Kubernetes organization.
So it's led by people from Kubernetes
full endorsement of the Kubernetes project,
a lot of backing, a lot of strength behind this project.
I put the link to the GitHub repository for it right here.
So you can try to visit that repository
and you're gonna see, okay, here's the page, documentation,
you see some stuff called like Nginx Ingress Controller.
Now, in addition to this ingress called ingress-nginx,
there is a completely separate project,
totally separate, that does almost the exact same thing,
with almost an identical name.
So a separate project out there
is called Kubernetes Ingress.
And this is also an Nginx-based ingress.
It is a project led by the company, Nginx.
It does like the same exact thing, almost identical name,
but it's a 100% separate, totally separate.
So right here, this is the GitHub repository for it.
I'm gonna go there as well.
And if you scroll down to the readme,
you're gonna see that this repository also
has a title of Nginx Ingress Controller.
Well, here's the project that we're using,
and it's also called very helpfully,
Nginx Ingress Controller.
So yeah, like these things are nearly identical in looking,
but again, they are very much separate projects,
and they work differently.
So whenever you are looking up documentation
you gotta be like 100% certain
that you're looking at documentation
for the ingress-nginx project.
So in general, I recommend that you go to
this GitHub repository, probably even bookmark it right now,
and anytime that you need to look up documentation,
come to this repo,
make sure you're looking at Kubernetes Ingress Nginx,
and then try to access documentation from this page
because otherwise you might accidentally fall into looking
at documentation for the other project,
the Kubernetes Ingress Project.
All right, so I know this is really confusing, but again,
I wanted to make a really big deal about this,
and make sure that it's 100% clear,
that yes, these are two separate projects.
We are not using this one, we are using this one.
So with that in mind, let's take a quick pause right here.
We're gonna come back to the next section,
with one or two other brief notes.