So hello everyone, today we're talking about the Incas and I'm going to create a private
cloud with system containers.
So just very quickly, I'm a CSAT main, basically, for many years, you're going to have
a league day and no Incas signed so a lot of time right now, because I work for
many of it.
It's not very interesting to run, just to run, to send our system containers with
Incas.
So what is Incas?
Incas is a foc of league day, it's basically the project that is the form it's basically
dead, no Incas is a new project, it's like an official website,
it's a next-generation system container manager and it turns into an application manager and
got your own magic.
So, many of you know of Kubernetes the out-of-way, okay, some, so it's very useful to learn
communities work, and for Incas, let's do Incas the out-of-way.
So what we will do, we will create a cluster from scratch, we'll configure it with
oven networking, create containers, inside it, we are in the container room, and I connect
to cluster and I look at the communication between the different network and each cluster.
So of course it's the out-of-way, you can do everything with automation, you can use
a project Incas deploy it to create a cluster, basically, instantly, but this top would
be very short if I use that, and for myself, I like to see all things actually work.
The slide I are here, if you want to pick up them, they are schema, but I think the screen
is big enough so you can get it a layer, give you some things.
All right, so what do we want to do?
We want to do a private code.
Let's say that we have two data centers, one, we will create a right cluster, and as
the other one, we will create a root cluster.
Each of them have a network connection with a router, and for a router, we will see
but they need to communicate in some way, that's not a story.
So let's try to do that in 20 minutes, so step one, or maybe step zero, oven.
We will use oven everywhere, so to speed things up a little bit, let's say that oven
is already configured.
By the way, when you see a right prompt, it's the right cluster, when you see a group
prompt, it's a blue cluster, it'd be easier for everyone.
So let's say that we already have an oven network configured, and you see three servers,
I have a tagamam, and they can communicate with the wind.
Right now, we need to create an increased cluster.
So in blue, that will be the thing that will be creating.
So for starters, very simple, we will initiate a cluster, to initiate a cluster, you
just wait to have a precede, it's not that hard, we just have to give it the IP address
of the host, and some default settings.
In this case, there is one default storage pool, and that's pretty much it.
So let's create the cluster.
So at this point, we have a cluster with one server, it's still a cluster, only one
server, so not very interesting, but wait, it is.
Let's complex a cluster, add two more nodes inside.
To do that, we go on this first server and create some join token, then we go on the
second server, beta in this case, and we will create another preset file.
In this case, it's a little different to join the first cluster, of course, so you need
to give it the IP address and the token.
For the gamma cluster, it's pretty much the same.
And at this point, we have a cluster, three nodes.
So we just did that, created an inclusive cluster, but there is no configuration, nor we
need to work in nothing.
So right now, we need to create one thing, that is the fling network, it will be the link
between every network inside the cluster and the sideworld, because at the server,
that cannot communicate with the sideworld, it's pretty much useless.
So let's begin by that.
In this case, we will dedicate a physical interface, an H node to the fling, it's the same
in this case.
We want all servers to be able to use a fling.
And we need to configure the fling in this case, it looks so scary, but it's not.
It's just that the IP before gateway is actually the external router to go to the outside
world.
So that's it.
And there, we will tell Incus to communicate with, because of course, he will need
to create some of the network, and we don't want to do that with as of in NFS.
So at this point, we did create a cluster and a new fling.
So now, we will create the real, I mean, the internal of the network where we will put
our containers, so it's important.
At this point, we can use Incus for basically everything, so the first command on the top
will create a network of a type of in.
And it will automatically generate, use, you can see the last time, it will use randomize
a network, but you can set whatever you want if you like it.
And it will use a fling to go outside the cluster.
So at this point, we are there.
Still no container, let's create our first container.
Right, the container is very easy, in this case, it's a system container, so we do that
like this.
And we just need to tell it where a witch network I will use and a witch storage.
So in this case, we will create a container, we don't even tell it where it will be created
because it's a cluster, so you'll see the location on the far, it's here and it will
be created on alpha, but you can be created on any member of the cluster as a key.
And then we can go inside the container, the system container, so you can run commands from
it, and you can do some things air, if you remember the right people, it's the gateway,
so it's outside the Incus cluster.
So in this case, the container has an antenna access.
So we are there, we have our first container, let's create another of in network, inside
it's just a cluster with another container.
So it's pretty much the same, we create a new network type of in, same common as before,
and then we create another container that uses this new network.
All right, we have two containers now.
So we can see, by the way, it was created on beta, this time, and they have two different
type of array, two different network, and they cannot communicate between them.
That's a default, by default, it's as it ended, because we don't want all networks
to communicate between them.
We may want to have some that have more preven numbers that don't have links.
If we go just a little bit in the oven hotel, they will say that the routing table, you
don't have to do that, but it's interesting to see, routing table is very simple, you
only have a default route at the moment.
So we are there, we have two of in network, separated, both have an antenna access, but
that's it.
All right, now, we have a location between two of in network, inside the same cluster.
That's basically appearing.
So we will peer the two networks, do you have plus common two in terms of networks?
You need to create a peer in bus ways, first way to the network one, to network two,
and to network two to network one.
But it's end the inquisterals to do that.
So when you did that, you can see the pairing right there, and you can see the peer in bus
direction.
All right?
And now, we can think containers from one network to another.
And if we look again as a routing table, and of in, we will see that there is a new route
in bus, in bus, hotel, virtual hotel, to give access to each network.
We are there at the moment.
So right now, if we want to continue and create our big cluster, basically it's an
ability to do that at this point.
If we want to create a region, we need our second cluster.
So I won't do the same again, but let's consider that we did the same with a blue cluster.
To a different point, we are there.
We have two clusters with a open network, virtual machine, whatever, but it cannot communicate
between them.
Each cluster doesn't know zero there, particularly.
So we will create a communication between them.
In a open terminology, it's a open interconnect, so we will connect two of in cluster,
basically.
So we need to do some of in configuration, and the command is a little scary, but in
fact, it's not that hard, it's just that we need to configure all the interconnect, to
know each of the members of the blue and red cluster, so that they can communicate between
them.
I like it in blue and red, it's IP, you don't have to do that by end again, this time.
And then you have some of in connection to do to configuration, it's here is to tell the
of in network that it must do at our connection, and I don't think you can see it's not
very important anyway.
So at this point, you need some more configuration that we will tell of in to automatically
learn the hood between the cluster, as you will have to add them manually in the routing
table, which can be in the long.
And here you can go back to in-cast, and you will need to create an iteration network.
This integration, it's purple, it's a purple, it's a name of our region, as a claim.
So here we, at the moment, there is only open integration, but in the future we can do some more,
and here you can, you have to tell in-cast where to communicate with the open interconnect
elements.
So it's the same configuration, as we did right there, in fact.
But this time, it allows in-cast to control, so if you end the elements to create a link
between networks.
And this, okay, it's a, it's a template to create, you don't have to name all the, all
the integrations.
Okay, so we need to do that on both cluster, blue and red, and at this time we did create
an interconnect connection between the two cluster.
So right now, we can come, we can peer to, to open network, we can make a link between
two of the network inside the clusters, for instance red net one, and blue net two, whatever
we want.
To do that, so it's a green thing, there, we will create a peer between two network
and side between the red and blue.
So the first thing, it's to tell the first cluster that it will create a connection between
one of its network, in this case, had net one, and that, it will, basically, export it,
that's what it's remotes, and that's it.
Now, if we look at, I don't, I don't want, we can look at the peer, and we will see
two peers, the first is a local peer, because at the beginning we did create a connection
where it had net one and net two, it's a local one, and the other one, the purple, is a
remotes one.
So it's ready to be connected to the other cluster.
So we do with the other same thing on the blue cluster, create a network situation, and
we, this time, we export, basically, the blue net one network, right?
So we did a, in bus side, we did exports for the red net one, and blue net one with
a notification name.
So if we look in, again, we will see the time that there is a port that was been created
to, to do the link, the actual link in, between the availability zone.
You can see availability zone blue in the top, and the command is pretty long, but availability
zone red, the bottom.
So there is a link in the vein between the two, two zone.
If we look at the ring table, we will see, and so, everything that's, that's oven as
added.
So this time you can, you will see the road to reach the other, and it's worth in the other
cluster.
And right now, we can try to ping things between the network.
So in this case, we did a link between the red net one network, and blue net one network.
So we go from the red net one to the oven, and connect, then to the other, and connect
on the blue one, and also way back to the oven network.
So right now, we can ping from the blue container one, red container one, and there,
and this is, and this is, and this is it, I guess I'm in pretty fast.
So at this point we did all this, so it's a world relation that was created, and we have
a cluster, right cluster, that is, availability zone red, and availability zone blue, and
we can add some more added green cluster, and whatever we want, and we can do a lot of things
actually, we can add firewalls in the routers, whatever we want, we can do pureing between
all of the, of the, of the in zone, and we can also add remotes between clusters, so
we can copy containers between one cluster to another one, and we'll just restart into
a cluster, do we have any questions, now, any questions, now?
So, yeah, I'm just going to just expand on that, it's like, you know, basically, so it's
the hard way, yeah, but we think as the play, you can do it the easy way, where you don't
just need to define an inventory of number of servers that you have, in this case, you
are doing clusters of three, so like, two clusters of three, and once you do it out, you
have to get the answer, but against that, it's going to figure out the IP addresses and put
the open services on that stuff, wherever it's needed, and when you do have two clusters,
then you can pick how to do the deal of an interconnect, the other thing here is the weight
was set up, is that every server was participating as a potential interconnect chassis,
I think we call it, so that's one way to do it, but in some environments, you're going
to have servers that have, that are going to be heavier on the network side, that have
like faster next and like, in which case you don't actually activate the, the interconnect
bit in open V-switch from every one of them, but just on the, on the ones that you want
to act as effectively the transit to go from one cluster to another, yeah, we're just showing
it, they probably because that's the simple way to do that, and it gets the play, so if anyone
uses it in case already, and you want to learn this stuff, in case the play, lets you
kind of do it nested effectively, so we've got Terraform files that will create a cluster
of five machines using VMs, so five VMs with shared storage, extra disk and everything,
and then when you run the Ansible bit, it's going to deploy other, save cluster that
VM basically all of those cluster features together for you and those machines, and then
you get to play with a cluster that's got basically all of those features, all enabled.
Yeah, thank you for the demo, and the Residation and the whole, can you put some light
on, you typically use cases, you can see for this kind of deal length, I mean, sorry,
for Ingels it, yeah, I mean, with comparison like with some lightweight Kubernetes installations
or something like this, yeah, it's a little different, I think I run Kubernetes and
side in case, if you want, I think, but for Ingels, you can run system containers that's
a little different from default application containers, you can have the run application
containers right now, but in this case, it's ready to create a private code, for us, it's
the basic infrastructure, it's below, it's on the hardware, the network, everything, if you
want to run Kubernetes, you can run Kubernetes inside the SID in case, basically.
Yeah, it's going to say like, pretty often for those deployments, so you want InCurse as the
bare metal solution, it runs directly on metal, it provides stability to do content, well,
because you can just input in our virtual machines at that level, and often for Kubernetes,
you're actually consuming a full physical machine, cannot stretch these Kubernetes in many ways,
where it's actually a better fit to create virtual machines on top of something like InCurse,
and then run your case cluster within that, because you're going to want to run many
different clusters, kind of different sizes, draw them, like, draw them, have some staging,
production, all that kind of stuff, so it actually makes more sense, and what we see are not
a fit rest in right now, with InCurse in those kind of deployments, like, proper that
that sent out your deployments with multiple sites, and all that kind of stuff, are people who
are moving away from VMware. So there's a lot of current VMware environments that are very
difficult, very complex, very expensive to run with the new licensing model, and they're
moving over to InCurse to a very private replacement for that, because we can run their
metal, we are multi-tenant, we support doing cross cluster network and supporting most of
the storage solutions, and those folks usually, they do run case, but they already run those
case clusters within VMs, so it works the exact same way.
I'm doing some case, it's nice to have system containers, because they are set full by default,
and for instance, for databases, it's easier to, in my, it's easier to run them in system containers.
What's there anyway, and if you can, it's okay, thank you very good, thanks a lot!