So, hello everyone. Thanks for joining. So, today I'm going to make a presentation titled
running containers under System G, exploring Pondman quadets and so on to the schedule, a short
words about me. Then we will talk about Pondman and the interesting parts would be Pondman
quadets and then we will do a demo to explore and see how we can use it to run gross Pondman
resources with System G. So, about myself, I'm a software engineer at Fedat. I've joined the
Pondman desktop team a little bit more than one years ago and that's my first time
much for them also. So, why working on Pondman desktop and Pondman? We saw that one big challenge
is moving from a local environment to a production environment. In pretty big company we often
have to team the development team, which are playing with containers, starting them putting them
from Docker IO and often needs other needs to orchestrate them because having one container running
is nice but having them communicate is better. So, we see compost being used in a lot of
projects and this is a nice tool to run things locally. But on the upstream for orchestrating containers
we often use Kubernetes because it offers way more extensibility, scalability and it's not the
same format. Compose is a specific kind of file and transforming it into Kubernetes.
General is often a complicated complicated task. So, we have this whole of discrepancy between
those two teams and in companies where or in places where we don't have two teams and on the
developer, we often see compost in a production environment like when you don't want to
bother having a full Kubernetes cluster or only have a small DPS or single server node,
you are pretty frustrated to have to deploy a full Kubernetes. So, you find alternative solution.
So, what is Pondman? Pondman for the name Pond Manager, before going into VAT in details, mainly
of Pondman is managing containers and images. It's compliance with the open container
initiative of CI and why you should use it? It's open source. It has been recently the nature
to be a plan that you have computing foundation this year and CF and it can mostly do
everything that Docker can do and it's one of its over goal but just managing containers is trying
to address the challenge that I was talking earlier and by this name Pond Manager, we can see Pond,
the unit resource of Kubernetes. What that means, it means that Pondman aim to support,
naturally without having a full cluster environments, Kubernetes resources. So, you can,
in the same five spec, take a pod, deployments, volume service or config map and run them directly
onto your machine with a Pondman installed. From your demo, next, I will use Pondman Desktop,
which is the UI tool for containers on giant containers with S because don't be tricked by the
name. It's aimed to work mainly with Pondman but if you have Docker installed, Lima or any of
a container in giant, you can explore your containers with it and this tool aimed to reach
also a gap to go further because it allows you to explore Kubernetes cluster resources in addition
of Pondman resources. But as I said earlier, the challenge is my local developer don't want
to have full Kubernetes cluster because it's just too much, too many features, too many elements
and it's taking all my CPU on my machine. So, what do you get if you squash a Kubernetes
Kubernetes? You get a quadlet. So, what's a quadlet? Quadlet came pretty recently in version of Pondman
to find a way to better integrate a Pondman resources with system D. So, why? So, first, we want
it away, just like we do with Kubernetes to take Pondman resources and make them run with
system D. So, we want it something declarative and to do that, we created something that we called
a system D generator. So, this is something for system D, but anyone can write. It's an executable
that is a Gipartist launch at runtime or reload time very early and it aims to transform
configuration file into dynamically generate unit files. So, you write, you declare your quadlet,
your container or quadlet, which will present a Pondman resources. You transform it, it is
transform it, sorry. It is converted through the quadlet system D generator into a system D file,
and it just run on your machine. Why? Not just writing the system D unit file,
because system D unit files are often very ost specific, like where is Pondman
in style, where is your container, I'm joined in style. And we want to be able to just
commit this file. I want to commit this configuration file and reuse it somewhere else and update
over server where I can just deploy it. Why just trying to do that with system D? Because on my
GPS machine, on my small server, I want to have a lifecycle, which is predictable. If my machine,
if my server is rebooted, I want my container, my resources to be rebooted. I don't want to have
to do some tricky magic to have it alive. And system D is predictable, because it's what make
all the services on the machine running. And for how it articulate for the configuration file,
it's just using some kind of system D syntax, with some syntax sugar and addition,
allowing you to define your resources. And we saw growing number of tools around this since
it has been introduced such as Podlet, which if you don't want to write this configuration file,
you can run your container and generate the quadlet for it. But in our world, let's see what
it looks like. So for example, here it's a quadlet container, like the very basic NJX services.
And you can see some very familiar option, like the Publish port, which is an option that
everyone is using. The container name, the image, which is the document, images, and why writing
that? As I said earlier, why not just writing the system D services, because having a full system D
services for a host is very specific. And it's very verbose. And it's easier to write something
like this, one on the left, and one on the right. So let's just go into the demo.
So first, let's take Podlet resources. So for this demo, it's just, is it zoomed enough?
So let's create a detached resources. We can name it, NJX for them. We can publish the port,
and we will use this. So this is a very traditional way of running a container.
I know that it's running. Now let's open Podlet Desktop. So this is a UI tool that I was talking earlier.
And Podlet Desktop has been made to be extensible. It's very inspired from VS code. So a lot of things
work with extension. And it has an extension to support quadlets. And it offers a few options.
So as I said earlier, we have growing tools, number of tools, with run quadlets. And from here,
I can just go here. And other additional option, which is generate quadlets from the resources,
but I started from the terminal, generated. And we can see that we are getting back the resources
that I was showing earlier. So we transformed the command the resources that we created in the terminal
to a file. And if we decided to just, I could just copy this file, commit it to a repository,
and reuse it on any Podman machine. Do you just need to watch system D installs of this can be
hard requirements for some people. So let's load that into the machine. And seem to be completed.
And I have it here. And let's open the details of this file. So this is the generated element.
This is a horrible one, but system D is going to be run. This is generated, as I was saying.
And this is the source file, but you should commit and reuse. You need to place it in some
specific folders. So here, Podman desktop did that for us. You need to place it in the
either in the user space or in the root space to have it run as root or not. You have to choose.
But since it's managed by system D, you need to use Johnard's TR to be able to follow the logs.
And here it is what we did. And I could just enable the services. And if we go back into the containers list,
we can see here that we have a different icon. Because Podman desktop is able to detect
that the container here in our case is managed by system D. And we can just stop the services here.
So disabling the system D services will kill the container and remove it.
But we are rarely just having one containers. We often are in the situation where we have
big compos file or tons of containers that we want to orchestrate. So let's just quickly show
an example here of a compos file. That I took online. There is like three big compos, three containers.
One, which is an NJX reverse proxy, a backend, which is just a flask application, which is built
from this folder. And a Mongo application, which act as a database. So let's just run that to see
if it works. So for a lot of components, Podman is also able to act as a replacement in most cases.
So let's start it. And let's go back to our Podman desktop application. And we can see here
what we have our compos application running. Let's see if I can access it nice.
If I can access it. So let's open in the browser. Here I will see,
hello from MongoDB clients. It's working. Great. But I didn't know if you knew. I just
run a compos application here. So let's go back here. Let's see if I can generate quadlets from
this file. Podman desktop is able to detect that this compos application was from this compos file.
And give us a few options. We can generate container cube type. Sorry, container quadlet type,
cube type, or pod type. For our example here, we will generate, because I was talking about the
gap between the development environment and the production environment. I will generate a cube
quadlet, which is a specific kind of quadlet. So let's do that. And we can see here that we have a few
options. And a lot of variables, jammals, Kubernetes like. So we can see here, similar to our previous
NJX container resources. We have two resources. Podman desktop can manage Kubernetes resources.
You just need to show where they are. So here we are linking our resources. And we can find back
the containers. So the NJX reverse proxy, our flask application and the Mongo. And let's just choose
where we want to deploy it. And load that into the machine. Go back here. But compared to our previous
step, I want to change maybe something. Sorry. Could be a mail cannot rebuild containers.
Podman can in our QBML file. Here, we only have flask. Flask is a folder in our working directory.
Podman desktop is able to detect, but you are pointing to this. And since in the
definition here, we added the build arguments. If I'm building it here,
which should be, okay, we have some good logs here. We can see that it's mounting. Oh,
it's doing people start opening the connection with the right. It seems it is.
And obviously it felt because I have my compose application running and it's conflicting
between my ports. So let's talk for a lot of that first. Let's do some cleanup.
Let's go back to our ports and let's start it again. Okay, I need to restart it. It's not.
Let's see, I have nothing. Okay, I have nothing now. And doing the build again.
And seems to be good. Enough logs, probably running. Go back here. Oh, and we can see that we have
our different containers with the icons saying that we are managed by system G. And let's see if
we have the right text, open in browser. Hello, first of them. So,
that was the obvious, but I hope it will get better in the future. So conclude. Podman,
Podman really tried to bridge between local environments and production environments.
Learning compose is something already pretty odd as learning Kubernetes. So why not just running
Kubernetes resources locally without having the overwhelming complexity of a full cluster.
What let's in addition of that and in combination, but allow you to type podman resources
with system G. So having them predictable lifecycle and reuse resources easily.
And thanks for listening. This is a link to an article of giving more details about Podman and the
request. If you have any questions, I think we have a few minutes. No, we're out of time. Thank you.
I will be outside if you have any questions.