WEBVTT

00:00.000 --> 00:16.160
So hello everyone, today we're talking about the Incas and I'm going to create a private

00:16.160 --> 00:19.280
cloud with system containers.

00:19.280 --> 00:25.280
So just very quickly, I'm a CSAT main, basically, for many years, you're going to have

00:25.280 --> 00:32.080
a league day and no Incas signed so a lot of time right now, because I work for

00:32.080 --> 00:33.080
many of it.

00:33.080 --> 00:38.320
It's not very interesting to run, just to run, to send our system containers with

00:38.320 --> 00:39.320
Incas.

00:39.320 --> 00:42.560
So what is Incas?

00:42.560 --> 00:49.080
Incas is a foc of league day, it's basically the project that is the form it's basically

00:49.080 --> 00:55.240
dead, no Incas is a new project, it's like an official website,

00:55.240 --> 01:00.760
it's a next-generation system container manager and it turns into an application manager and

01:00.760 --> 01:02.680
got your own magic.

01:02.680 --> 01:17.600
So, many of you know of Kubernetes the out-of-way, okay, some, so it's very useful to learn

01:17.600 --> 01:25.600
communities work, and for Incas, let's do Incas the out-of-way.

01:25.600 --> 01:30.800
So what we will do, we will create a cluster from scratch, we'll configure it with

01:30.800 --> 01:37.400
oven networking, create containers, inside it, we are in the container room, and I connect

01:37.400 --> 01:43.800
to cluster and I look at the communication between the different network and each cluster.

01:43.800 --> 01:49.640
So of course it's the out-of-way, you can do everything with automation, you can use

01:49.640 --> 01:55.880
a project Incas deploy it to create a cluster, basically, instantly, but this top would

01:55.880 --> 02:03.920
be very short if I use that, and for myself, I like to see all things actually work.

02:03.920 --> 02:10.160
The slide I are here, if you want to pick up them, they are schema, but I think the screen

02:10.240 --> 02:18.640
is big enough so you can get it a layer, give you some things.

02:18.640 --> 02:24.480
All right, so what do we want to do?

02:24.480 --> 02:28.040
We want to do a private code.

02:28.040 --> 02:34.640
Let's say that we have two data centers, one, we will create a right cluster, and as

02:34.720 --> 02:37.800
the other one, we will create a root cluster.

02:37.800 --> 02:45.480
Each of them have a network connection with a router, and for a router, we will see

02:45.480 --> 02:52.240
but they need to communicate in some way, that's not a story.

02:52.240 --> 03:01.000
So let's try to do that in 20 minutes, so step one, or maybe step zero, oven.

03:01.040 --> 03:08.000
We will use oven everywhere, so to speed things up a little bit, let's say that oven

03:08.000 --> 03:11.240
is already configured.

03:11.240 --> 03:16.000
By the way, when you see a right prompt, it's the right cluster, when you see a group

03:16.000 --> 03:20.280
prompt, it's a blue cluster, it'd be easier for everyone.

03:20.280 --> 03:28.640
So let's say that we already have an oven network configured, and you see three servers,

03:28.640 --> 03:34.280
I have a tagamam, and they can communicate with the wind.

03:34.280 --> 03:39.320
Right now, we need to create an increased cluster.

03:39.320 --> 03:43.960
So in blue, that will be the thing that will be creating.

03:43.960 --> 03:51.640
So for starters, very simple, we will initiate a cluster, to initiate a cluster, you

03:51.640 --> 03:58.440
just wait to have a precede, it's not that hard, we just have to give it the IP address

03:58.440 --> 04:02.880
of the host, and some default settings.

04:02.880 --> 04:08.760
In this case, there is one default storage pool, and that's pretty much it.

04:08.760 --> 04:16.880
So let's create the cluster.

04:16.880 --> 04:23.340
So at this point, we have a cluster with one server, it's still a cluster, only one

04:23.340 --> 04:29.040
server, so not very interesting, but wait, it is.

04:29.040 --> 04:33.240
Let's complex a cluster, add two more nodes inside.

04:33.240 --> 04:43.320
To do that, we go on this first server and create some join token, then we go on the

04:43.320 --> 04:49.400
second server, beta in this case, and we will create another preset file.

04:49.400 --> 04:52.920
In this case, it's a little different to join the first cluster, of course, so you need

04:52.920 --> 04:58.400
to give it the IP address and the token.

04:58.400 --> 05:02.160
For the gamma cluster, it's pretty much the same.

05:02.160 --> 05:08.840
And at this point, we have a cluster, three nodes.

05:08.840 --> 05:15.440
So we just did that, created an inclusive cluster, but there is no configuration, nor we

05:15.440 --> 05:17.560
need to work in nothing.

05:17.560 --> 05:24.520
So right now, we need to create one thing, that is the fling network, it will be the link

05:24.520 --> 05:30.280
between every network inside the cluster and the sideworld, because at the server,

05:30.280 --> 05:34.200
that cannot communicate with the sideworld, it's pretty much useless.

05:34.200 --> 05:37.160
So let's begin by that.

05:37.160 --> 05:48.160
In this case, we will dedicate a physical interface, an H node to the fling, it's the same

05:48.160 --> 05:49.160
in this case.

05:49.160 --> 05:53.240
We want all servers to be able to use a fling.

05:53.240 --> 05:59.520
And we need to configure the fling in this case, it looks so scary, but it's not.

05:59.520 --> 06:07.940
It's just that the IP before gateway is actually the external router to go to the outside

06:07.940 --> 06:10.080
world.

06:10.080 --> 06:14.400
So that's it.

06:14.400 --> 06:19.880
And there, we will tell Incus to communicate with, because of course, he will need

06:19.880 --> 06:27.720
to create some of the network, and we don't want to do that with as of in NFS.

06:27.720 --> 06:34.360
So at this point, we did create a cluster and a new fling.

06:34.360 --> 06:40.800
So now, we will create the real, I mean, the internal of the network where we will put

06:40.800 --> 06:46.160
our containers, so it's important.

06:46.160 --> 06:53.880
At this point, we can use Incus for basically everything, so the first command on the top

06:53.880 --> 06:59.000
will create a network of a type of in.

06:59.000 --> 07:06.160
And it will automatically generate, use, you can see the last time, it will use randomize

07:06.160 --> 07:10.360
a network, but you can set whatever you want if you like it.

07:10.360 --> 07:16.400
And it will use a fling to go outside the cluster.

07:16.400 --> 07:18.400
So at this point, we are there.

07:18.400 --> 07:22.800
Still no container, let's create our first container.

07:22.800 --> 07:31.320
Right, the container is very easy, in this case, it's a system container, so we do that

07:31.320 --> 07:32.920
like this.

07:32.920 --> 07:40.960
And we just need to tell it where a witch network I will use and a witch storage.

07:40.960 --> 07:46.160
So in this case, we will create a container, we don't even tell it where it will be created

07:46.160 --> 07:52.000
because it's a cluster, so you'll see the location on the far, it's here and it will

07:52.000 --> 07:59.000
be created on alpha, but you can be created on any member of the cluster as a key.

07:59.000 --> 08:03.240
And then we can go inside the container, the system container, so you can run commands from

08:03.240 --> 08:11.440
it, and you can do some things air, if you remember the right people, it's the gateway,

08:11.440 --> 08:15.360
so it's outside the Incus cluster.

08:15.360 --> 08:21.360
So in this case, the container has an antenna access.

08:21.360 --> 08:28.600
So we are there, we have our first container, let's create another of in network, inside

08:28.600 --> 08:32.800
it's just a cluster with another container.

08:32.800 --> 08:41.320
So it's pretty much the same, we create a new network type of in, same common as before,

08:41.320 --> 08:47.440
and then we create another container that uses this new network.

08:47.440 --> 08:50.960
All right, we have two containers now.

08:50.960 --> 08:56.960
So we can see, by the way, it was created on beta, this time, and they have two different

08:56.960 --> 09:02.240
type of array, two different network, and they cannot communicate between them.

09:02.240 --> 09:09.800
That's a default, by default, it's as it ended, because we don't want all networks

09:09.800 --> 09:10.880
to communicate between them.

09:10.880 --> 09:17.240
We may want to have some that have more preven numbers that don't have links.

09:17.240 --> 09:24.840
If we go just a little bit in the oven hotel, they will say that the routing table, you

09:24.840 --> 09:29.000
don't have to do that, but it's interesting to see, routing table is very simple, you

09:29.000 --> 09:34.840
only have a default route at the moment.

09:34.840 --> 09:39.920
So we are there, we have two of in network, separated, both have an antenna access, but

09:39.920 --> 09:42.800
that's it.

09:42.800 --> 09:51.680
All right, now, we have a location between two of in network, inside the same cluster.

09:51.680 --> 09:55.200
That's basically appearing.

09:55.200 --> 10:02.280
So we will peer the two networks, do you have plus common two in terms of networks?

10:02.280 --> 10:08.360
You need to create a peer in bus ways, first way to the network one, to network two,

10:08.360 --> 10:10.800
and to network two to network one.

10:10.800 --> 10:15.160
But it's end the inquisterals to do that.

10:15.160 --> 10:23.200
So when you did that, you can see the pairing right there, and you can see the peer in bus

10:23.200 --> 10:24.200
direction.

10:24.200 --> 10:26.600
All right?

10:26.600 --> 10:33.680
And now, we can think containers from one network to another.

10:33.680 --> 10:40.520
And if we look again as a routing table, and of in, we will see that there is a new route

10:40.520 --> 10:50.240
in bus, in bus, hotel, virtual hotel, to give access to each network.

10:50.240 --> 10:52.680
We are there at the moment.

10:52.680 --> 11:02.440
So right now, if we want to continue and create our big cluster, basically it's an

11:02.440 --> 11:04.520
ability to do that at this point.

11:04.520 --> 11:09.120
If we want to create a region, we need our second cluster.

11:09.120 --> 11:16.880
So I won't do the same again, but let's consider that we did the same with a blue cluster.

11:16.880 --> 11:18.800
To a different point, we are there.

11:18.800 --> 11:25.760
We have two clusters with a open network, virtual machine, whatever, but it cannot communicate

11:25.760 --> 11:26.760
between them.

11:26.760 --> 11:32.000
Each cluster doesn't know zero there, particularly.

11:32.000 --> 11:35.400
So we will create a communication between them.

11:35.400 --> 11:45.920
In a open terminology, it's a open interconnect, so we will connect two of in cluster,

11:45.920 --> 11:49.760
basically.

11:49.760 --> 11:58.840
So we need to do some of in configuration, and the command is a little scary, but in

11:58.880 --> 12:05.760
fact, it's not that hard, it's just that we need to configure all the interconnect, to

12:05.760 --> 12:12.080
know each of the members of the blue and red cluster, so that they can communicate between

12:12.080 --> 12:13.080
them.

12:13.080 --> 12:23.360
I like it in blue and red, it's IP, you don't have to do that by end again, this time.

12:23.360 --> 12:31.940
And then you have some of in connection to do to configuration, it's here is to tell the

12:31.940 --> 12:40.800
of in network that it must do at our connection, and I don't think you can see it's not

12:40.800 --> 12:44.760
very important anyway.

12:44.760 --> 12:53.200
So at this point, you need some more configuration that we will tell of in to automatically

12:53.200 --> 12:57.960
learn the hood between the cluster, as you will have to add them manually in the routing

12:57.960 --> 13:03.600
table, which can be in the long.

13:03.600 --> 13:11.960
And here you can go back to in-cast, and you will need to create an iteration network.

13:11.960 --> 13:20.000
This integration, it's purple, it's a purple, it's a name of our region, as a claim.

13:20.000 --> 13:27.920
So here we, at the moment, there is only open integration, but in the future we can do some more,

13:27.920 --> 13:36.880
and here you can, you have to tell in-cast where to communicate with the open interconnect

13:36.880 --> 13:39.160
elements.

13:39.160 --> 13:48.720
So it's the same configuration, as we did right there, in fact.

13:48.720 --> 13:57.260
But this time, it allows in-cast to control, so if you end the elements to create a link

13:57.260 --> 14:00.460
between networks.

14:00.460 --> 14:06.900
And this, okay, it's a, it's a template to create, you don't have to name all the, all

14:06.900 --> 14:09.420
the integrations.

14:09.420 --> 14:21.020
Okay, so we need to do that on both cluster, blue and red, and at this time we did create

14:21.020 --> 14:25.780
an interconnect connection between the two cluster.

14:25.780 --> 14:34.540
So right now, we can come, we can peer to, to open network, we can make a link between

14:34.540 --> 14:40.700
two of the network inside the clusters, for instance red net one, and blue net two, whatever

14:40.700 --> 14:41.700
we want.

14:41.700 --> 14:55.220
To do that, so it's a green thing, there, we will create a peer between two network

14:55.220 --> 15:00.180
and side between the red and blue.

15:00.180 --> 15:05.660
So the first thing, it's to tell the first cluster that it will create a connection between

15:05.660 --> 15:12.420
one of its network, in this case, had net one, and that, it will, basically, export it,

15:12.420 --> 15:17.740
that's what it's remotes, and that's it.

15:17.740 --> 15:22.780
Now, if we look at, I don't, I don't want, we can look at the peer, and we will see

15:22.780 --> 15:27.580
two peers, the first is a local peer, because at the beginning we did create a connection

15:27.580 --> 15:34.860
where it had net one and net two, it's a local one, and the other one, the purple, is a

15:34.860 --> 15:35.860
remotes one.

15:35.860 --> 15:41.820
So it's ready to be connected to the other cluster.

15:41.820 --> 15:50.740
So we do with the other same thing on the blue cluster, create a network situation, and

15:50.780 --> 15:58.420
we, this time, we export, basically, the blue net one network, right?

15:58.420 --> 16:04.060
So we did a, in bus side, we did exports for the red net one, and blue net one with

16:04.060 --> 16:07.420
a notification name.

16:07.420 --> 16:16.300
So if we look in, again, we will see the time that there is a port that was been created

16:16.300 --> 16:22.860
to, to do the link, the actual link in, between the availability zone.

16:22.860 --> 16:30.740
You can see availability zone blue in the top, and the command is pretty long, but availability

16:30.740 --> 16:32.140
zone red, the bottom.

16:32.140 --> 16:40.460
So there is a link in the vein between the two, two zone.

16:40.460 --> 16:47.100
If we look at the ring table, we will see, and so, everything that's, that's oven as

16:47.100 --> 16:48.100
added.

16:48.100 --> 16:55.740
So this time you can, you will see the road to reach the other, and it's worth in the other

16:55.740 --> 16:59.100
cluster.

16:59.100 --> 17:03.660
And right now, we can try to ping things between the network.

17:03.660 --> 17:15.980
So in this case, we did a link between the red net one network, and blue net one network.

17:15.980 --> 17:23.820
So we go from the red net one to the oven, and connect, then to the other, and connect

17:23.820 --> 17:32.700
on the blue one, and also way back to the oven network.

17:32.700 --> 17:48.140
So right now, we can ping from the blue container one, red container one, and there,

17:48.140 --> 17:59.140
and this is, and this is, and this is it, I guess I'm in pretty fast.

17:59.140 --> 18:07.020
So at this point we did all this, so it's a world relation that was created, and we have

18:07.020 --> 18:15.180
a cluster, right cluster, that is, availability zone red, and availability zone blue, and

18:15.180 --> 18:21.980
we can add some more added green cluster, and whatever we want, and we can do a lot of things

18:21.980 --> 18:30.420
actually, we can add firewalls in the routers, whatever we want, we can do pureing between

18:30.420 --> 18:40.500
all of the, of the, of the in zone, and we can also add remotes between clusters, so

18:40.500 --> 18:49.140
we can copy containers between one cluster to another one, and we'll just restart into

18:49.140 --> 19:13.260
a cluster, do we have any questions, now, any questions, now?

19:13.260 --> 19:34.060
So, yeah, I'm just going to just expand on that, it's like, you know, basically, so it's

19:34.060 --> 19:41.060
the hard way, yeah, but we think as the play, you can do it the easy way, where you don't

19:41.140 --> 19:48.780
just need to define an inventory of number of servers that you have, in this case, you

19:48.780 --> 19:54.220
are doing clusters of three, so like, two clusters of three, and once you do it out, you

19:54.220 --> 19:57.780
have to get the answer, but against that, it's going to figure out the IP addresses and put

19:57.780 --> 20:02.460
the open services on that stuff, wherever it's needed, and when you do have two clusters,

20:02.460 --> 20:07.820
then you can pick how to do the deal of an interconnect, the other thing here is the weight

20:07.860 --> 20:16.820
was set up, is that every server was participating as a potential interconnect chassis,

20:16.820 --> 20:21.180
I think we call it, so that's one way to do it, but in some environments, you're going

20:21.180 --> 20:26.460
to have servers that have, that are going to be heavier on the network side, that have

20:26.460 --> 20:33.300
like faster next and like, in which case you don't actually activate the, the interconnect

20:33.300 --> 20:37.020
bit in open V-switch from every one of them, but just on the, on the ones that you want

20:37.020 --> 20:48.780
to act as effectively the transit to go from one cluster to another, yeah, we're just showing

20:48.780 --> 20:55.060
it, they probably because that's the simple way to do that, and it gets the play, so if anyone

20:55.060 --> 20:59.460
uses it in case already, and you want to learn this stuff, in case the play, lets you

20:59.460 --> 21:04.620
kind of do it nested effectively, so we've got Terraform files that will create a cluster

21:04.620 --> 21:12.140
of five machines using VMs, so five VMs with shared storage, extra disk and everything,

21:12.140 --> 21:17.500
and then when you run the Ansible bit, it's going to deploy other, save cluster that

21:17.500 --> 21:22.100
VM basically all of those cluster features together for you and those machines, and then

21:22.100 --> 21:26.900
you get to play with a cluster that's got basically all of those features, all enabled.

21:29.460 --> 21:45.860
Yeah, thank you for the demo, and the Residation and the whole, can you put some light

21:45.860 --> 21:55.460
on, you typically use cases, you can see for this kind of deal length, I mean, sorry,

21:55.460 --> 22:03.940
for Ingels it, yeah, I mean, with comparison like with some lightweight Kubernetes installations

22:03.940 --> 22:14.740
or something like this, yeah, it's a little different, I think I run Kubernetes and

22:14.740 --> 22:22.340
side in case, if you want, I think, but for Ingels, you can run system containers that's

22:22.340 --> 22:29.180
a little different from default application containers, you can have the run application

22:29.180 --> 22:38.980
containers right now, but in this case, it's ready to create a private code, for us, it's

22:38.980 --> 22:48.100
the basic infrastructure, it's below, it's on the hardware, the network, everything, if you

22:48.100 --> 22:53.780
want to run Kubernetes, you can run Kubernetes inside the SID in case, basically.

22:53.780 --> 22:58.740
Yeah, it's going to say like, pretty often for those deployments, so you want InCurse as the

22:58.740 --> 23:04.820
bare metal solution, it runs directly on metal, it provides stability to do content, well,

23:04.820 --> 23:08.900
because you can just input in our virtual machines at that level, and often for Kubernetes,

23:08.900 --> 23:14.500
you're actually consuming a full physical machine, cannot stretch these Kubernetes in many ways,

23:14.500 --> 23:18.580
where it's actually a better fit to create virtual machines on top of something like InCurse,

23:18.580 --> 23:22.740
and then run your case cluster within that, because you're going to want to run many

23:22.740 --> 23:26.900
different clusters, kind of different sizes, draw them, like, draw them, have some staging,

23:26.900 --> 23:31.940
production, all that kind of stuff, so it actually makes more sense, and what we see are not

23:31.940 --> 23:36.500
a fit rest in right now, with InCurse in those kind of deployments, like, proper that

23:36.500 --> 23:39.940
that sent out your deployments with multiple sites, and all that kind of stuff, are people who

23:39.940 --> 23:47.220
are moving away from VMware. So there's a lot of current VMware environments that are very

23:47.220 --> 23:52.020
difficult, very complex, very expensive to run with the new licensing model, and they're

23:52.020 --> 23:56.340
moving over to InCurse to a very private replacement for that, because we can run their

23:56.340 --> 24:02.420
metal, we are multi-tenant, we support doing cross cluster network and supporting most of

24:02.420 --> 24:08.340
the storage solutions, and those folks usually, they do run case, but they already run those

24:08.340 --> 24:11.060
case clusters within VMs, so it works the exact same way.

24:11.060 --> 24:19.140
I'm doing some case, it's nice to have system containers, because they are set full by default,

24:19.220 --> 24:27.220
and for instance, for databases, it's easier to, in my, it's easier to run them in system containers.

24:31.300 --> 24:38.180
What's there anyway, and if you can, it's okay, thank you very good, thanks a lot!

