At Clever Cloud, the CaaS offering relies on managed Docker runtimes. It is widely used by our customers.

CaaS in the cloud ecosystem

CaaS provides an environment where containers can be deployed, executed, and monitored without the user needing to administer servers or clusters. It allows teams to work directly with their container images while delegating operational tasks such as monitoring, security updates, and scaling.

This model stands out by combining portability (a container can run on any compatible environment) and operational simplicity. It does not replace other cloud approaches but occupies an intermediate position.

CaaS, IaaS, PaaS, FaaS, DBaaS: understanding the differences

To better situate CaaS, it helps to compare it with other service models:

• IaaS (Infrastructure as a Service): you manage virtual machines, storage, and networking. Flexible but demanding, it requires significant administrative investment.
• PaaS (Platform as a Service): you deploy your applications directly on a platform that manages the infrastructure and part of the software stack. Fast and convenient—this is Clever Cloud’s core expertise.
• FaaS (Function as a Service): you run functions that are triggered on demand. Very useful for specific use cases.
• DBaaS (Database as a Service): the provider handles deployment, hosting, and maintenance of a database. You benefit from a database that is always available, secure, and backed up, without having to manage updates or complex configuration.
• CaaS (Container as a Service): you deploy your containers, often with Docker, while delegating hosting, supervision, and maintenance of the runtime environment to a provider.

Thus, CaaS appears as a compromise: it gives developers the freedom to use their containers while reducing operational overhead.

The role of containers and Docker

Containers have become a standard for deploying applications. They package an application and all its dependencies into an isolated environment, ensuring consistent execution regardless of the context.

Docker has established itself as the reference tool for creating and managing containers. Its widespread adoption is explained by:

• Portability: a container runs the same way in development, testing, or production.
• Consistency: no more configuration discrepancies between machines.
• Speed: deployment is much faster than with a traditional VM.

These qualities make Docker a natural foundation for CaaS.

Managed Docker at Clever Cloud

At Clever Cloud, we provide Docker as a managed service. In practice, this means you deploy your Docker containers on our platform, and we host, run, keep the Docker image up to date, and provide monitoring and scalability.

Important note: only you can update the content of your container.

You remain in control of your Docker containers, but you no longer need to manage the lower layers of the infrastructure. This approach is aligned with our mission: delivering reliable managed services so teams can focus on code rather than administration.

Docker with an extra layer of security

Clever Cloud deploys your Docker containers inside VMs to ensure strong isolation and therefore reinforce security.

👉 Access the Clever Cloud console to test Docker deployment

When CaaS makes sense

CaaS is not universal, but it is well suited to certain situations:

• Startups: quickly launch a service without mobilizing a full ops team.
• Software vendors: industrialize the deployment of their containerized applications while benefiting from a stable environment.
• Large enterprises: centralize container management across several teams, with operational support.

In all these cases, the goal remains the same: improving efficiency without sacrificing control over applications.

CaaS: making Docker users’ lives easier

CaaS is not a replacement for PaaS or DBaaS but a complementary option in the cloud landscape. It is designed for teams that want to run their Docker containers while delegating operational management.

At Clever Cloud, we therefore provide this CaaS component to support projects that need it. By focusing on the operational maintenance of Docker, we provide a secure and efficient framework for deploying containers without the burden of day-to-day management.

FAQ: CaaS and managed Docker

What is CaaS (Container as a Service)?
CaaS is a cloud computing model that allows you to deploy and manage containers without administering the underlying infrastructure. It offers a balance between flexibility and operational simplicity.

What does Docker bring to CaaS?
Docker is the most widely used tool for building and running containers. It ensures portability, rapid deployment, and consistency across environments. In a CaaS model, Docker is often the core technology.

What does “managed Docker” mean at Clever Cloud?
It means you deploy your Docker containers on Clever Cloud, and the platform ensures their operational maintenance: monitoring, Docker image updates, backups, and automatic scaling.

Dans cet épisode très ouvert il est question de Rust qui est à la base de wymmo.com (le portail de notre invité), du ralentissement du secteur, de Docker pousse l'open source vers le payant et d'histoire de nos machines. Nous passons un moment à parler d'IA : annonce de GPT4, CopilotX, LLaMA avant de présenter quelques outils et de finir en musique.

Avec la participation de @juuduu
Emmanuel Bosquet (@EmmanuelBosquet) / Twitter
Guillaume Assier 🔋 (@GuillaumeAssier) / Twitter
jrx - Eventually Consultant - C# .. 🦀⚙️ (@jrouaix) / Twitter

Épisode enregistré le 24 mars 2023.

👋 Venez discuter avec nous sur @clever_cloudFR pour nous dire ce que vous avez pensé de ce nouvel épisode.

➡️ Pour découvrir ou réécouter d’anciens épisodes c’est par ici !

Timecode & Liens

00:00:16 - Présentation des participants

00:01:27 Projet pro : https://wymmo.com/

00:09:28 Et sinon le ralentissement dans notre secteur, vous le ressentez ?
https://www.lesechos.fr/start-up/next40-vivatech/payfit-se-separe-de-20-de-ses-effectifs-1910932
https://emploi.developpez.com/actu/342624/Y-a-t-il-une-bulle-dans-l-industrie-Tech-et-est-elle-en-train-d-eclater-Les-donnees-sur-les-offres-d-emploi-le-suggerent-mais-les-experts-estiment-que-c-est-le-moment-ideal-pour-y-travailler/

00:21:18 : Docker pousse l’open source vers un modèle payant
https://blog.alexellis.io/docker-is-deleting-open-source-images/
Faut faire du blé… devenir rentable
0€ −> 420€/an
Changement dans un mois.

00:28:58 Un peu d'histoire (en podcast), d'où viennent nos machines (Jérôme):

• https://techcafe.fr/steampunk-cafe-machine-de-babbage-et-autres-machines-a-vapeur/
  Métiers à tisser, cartes perforés, ordinateur à vapeur et machines analogiques (beaucoup de liens en description)
• https://techcafe.fr/supplement-steampunk-cafe-2-langleterre-du-colossus-a-lamstrad/
  La suite de l'Histoire et premiers transistors
  00:34:04 : Eloge duclavier BEPO
  https://bepo.fr/wiki/Accueil
  Klavaro : https://klavaro.sourceforge.io/fr/index.html

00:38:40 Open AI ne sera plus “open” et annonce GPT-4 (Jérôme)
https://openai.com/research/gpt-4
https://www.theverge.com/2023/3/15/23640180/openai-gpt-4-launch-closed-research-ilya-sutskever-interview
- L'IA passe de l'ère de la recherche à l'ère du secret
- "Open" AI n'a jamais si mal porté son nom

00:44:34 : CopilotX
https://github.blog/2023-03-22-github-copilot-x-the-ai-powered-developer-experience/ (Emmanuel)

00:49:21 : Comment fonctionnent les IA tels GPT-x
https://www.joshwcomeau.com/blog/the-end-of-frontend-development/

00:57:56 : Demandes DMCA des dépôts basés sur le modèle LLaMA (Large Language Model Meta AI) par Meta
Lama-dl + forks
https://twitter.com/theshawwn/status/1638925249709240322
https://github.com/github/dmca/blob/master/2023/03/2023-03-21-meta.md
https://twitter.com/Dorialexander/status/1638992849516544000?s=20

01:00:29 : Vol de compte meta via une extension chrome qui surfe sur la vague chatgpt
https://thehackernews.com/2023/03/fake-chatgpt-chrome-browser-extension.html

01:02:26 : Support en alpha des plugins dans chatgpt qui va améliorer son expérience produit
https://openai.com/blog/chatgpt-plugins

01:04:00 : Codegenr, l’outil de la semaine
https://github.com/eventuallyconsultant/codegenr

01:11:56 : Musique de fin - Sound of science - Portal
https://www.youtube.com/watch?v=l0xh4qopQpk

Si les dés en avait décidé autrement, il y aurait pu avoir :

• Julien : https://www.youtube.com/watch?v=BtxTSXhZbOQ Ma’agalim, Idan Raichel
• Guillaume : https://www.youtube.com/watch?v=hVvx8cZcklQ When You’re Around, Oliver Tree
• Jérôme : https://www.youtube.com/watch?v=6AbssmQ7EPI&list=PLD27AC29593FA45A7&index=18

Dans cet épisode de haute tenue, nos incroyables convives parlent de Debian, de Servo, de Rust, de CPU, de Cloud Hypervisor 29, d’un outil pour iMessage, de Docker, de BIOS et d’Oracle avant de finir immergé en musique.

Avec la participation de @waxzce, @gwinizdu, @blackyoup et @_nidouille_.

👋 Venez discuter avec nous sur @clever_cloudFR pour nous dire ce que vous avez pensé de ce nouvel épisode.

➡️ Pour découvrir ou réécouter d’anciens épisodes c’est par ici !

Timecode & Liens

00:00:00 - Générique
00:00:16 - Intro et présentation des invités

00:01:332 - Debian 12

https://twitter.com/ponceto91/status/1616329686564454402

00:03:56 - Servo, père de Rust n’est pas mort

https://servo.org/blog/2023/01/16/servo-2023/

00:10:42 - What happens when a CPU starts
https://lateblt.tripod.com/bit68.txt

00:15:13 - Chromium supporte (enfin) Rust
https://security.googleblog.com/2023/01/supporting-use-of-rust-in-chromium.html

00:17:29 - Rust vs C++
https://www.youtube.com/watch?v=VMpSYJ_7aYM
https://fasterthanli.me/

00:21:57 - Rust concept i wish i learn earlier

https://twitter.com/waxzce/status/1616364663138140163

00:23:27 - Cloud Hypervisor 29
https://www.phoronix.com/news/Cloud-Hypervisor-29

00:28:37 - iMessage exporter

https://twitter.com/waxzce/status/1615645927015948288

00:30:44 - News Apple - Nouveau MacBook Pro M2 et M2 Pro

https://www.macrumors.com/2023/01/19/new-macs-and-homepod-recap/

00:33:38 - Docker for Mac

https://twitter.com/tobias_petry/status/1613837074356129792

00:34:39 - Unbricking a BIOS-bricked motherboard
https://davidesnotes.com/shorts/1/

00:41:12 - Oracle on PG
https://ivorysql.org/

00:42:06 - Rappel de comment fonctionne un query engine de DB
https://howqueryengineswork.com/

00:42:59 - La musique de l’épisode : The Little Rabbits - La piscine - Barclay

https://www.youtube.com/watch?v=FWZcIcgsgh4

Ou bien :

https://www.dailymotion.com/video/x5ho3v7

We're talking about Docker today! As you may know, Docker has a tremendous amount of images on their public registry. But sometimes you may need to pull images from a private Docker registry. Mostly because you can't always publicly publish the images. So, we've added a few environement variables to allow you to fetch these images, let's see how to do it.

In this note post we assume you already have your own Docker registry. If this isn't the case, you can see how to deploy a registry server here.

So, pulling private images is done through the docker build command. To login to a private registry, you need to set a few environment variables:

• CC_DOCKER_LOGIN_USERNAME: the username to use to login
• CC_DOCKER_LOGIN_PASSWORD: the password of your username
• CC_DOCKER_LOGIN_SERVER (optionnal): the server of your private registry. Defaults to Docker's public registry.

This uses the docker login command under the hood.

Build-time variables

You can use the ARG instruction to define build-time environment variables. Every environment variable defined for your application will be passed as a build environment variable using the --build-arg=<ENV> parameter during the docker build.

Source image: Vladimir Malyavko

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Docker.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Docker?

Docker is a software technology providing containers, promoted by the company Docker, Inc.

I am assuming everone know what it is so I won't go in further explanations. That being said, if you are familiar with Clever Cloud, you may know we have a reputation of not being big fans of Docker. Yet you can deploy Docker containers on Clever Cloud and we were actually one of the first cloud to offer it.

We do like Docker but as a public cloud we have to isolate each containers in a VM for proper isolation. We have to have an absolute position when it comes to security. Anyway, please let us know in the comments if you want us to talk more about our position on Docker and containers. We plan to do a lot more on that side, we just need a bit more time to release it to the public :)

So why talking about Docker today? Well it turns out some of our users asked us if it was possible to deploy Keycloak on Clever Cloud. So I looked into it. There are various way to deploy it. The first way I wanted to use was to deploy it as a Wildfly overlay using their .war.

But sadly it's not recommended in production. You have to use their full wildfly distribution. So I could either download the whole thing each time I start the application, or deploy the Docker container they offer and support in Production. Which is what I have chosen.

Setup

Keycloak Docker images are all available on Github. And has you need to provide a Dockerfile in your source code for us to build, I copied the official one for the HA/PosgreSQL configuration. I would have gladly forked the repo but it contains all their images. Not very 12 factors compliant sadly :( Anyway my git repository looks like this:

[ldoguin@caolila keycloakClever]$ ls
Dockerfile

and the Dockerfile like this:

FROM jboss/keycloak-postgres:3.4.0.Final

CMD ["-b", "0.0.0.0", "--server-config", "standalone-ha.xml"]

We don't have anything specific to add to this Dockerfile. It's very well configured and easy to use. We now need to create the Clever Cloud application and its associated database then setup the right environmment variables:

• Create our application: clever create --type docker --plan M Keycloak
• Create our Postgres add-on: clever addon create postgresql-addon --plan dev --region eu KeycloakPG
• Link this website to our FS Bucket addon: clever service link-addon KeycloakPG
• Setup the following environment variables:

clever env set ENABLE_METRICS true
clever env set PROXY_ADDRESS_FORWARDING true
clever env set KEYCLOAK_PASSWORD admin
clever env set KEYCLOAK_USER admin
clever env set JAVA_OPTS "-Djgroups.bind_addr=127.0.0.1"
clever env set POSTGRES_DATABASE `clever env | awk  -F = '/POSTGRESQL_ADDON_DB/ { print $2}'
clever env set POSTGRES_PASSWORD `clever env | awk  -F = '/POSTGRESQL_ADDON_PASSWORD/ { print $2}'
clever env set POSTGRES_PORT_5432_TCP_ADDR `clever env | awk  -F = '/POSTGRESQL_ADDON_HOST/ { print $2}'
clever env set POSTGRES_PORT_5432_TCP_PORT `clever env | awk  -F = '/POSTGRESQL_ADDON_PORT/ { print $2}'
clever env set POSTGRES_USER `clever env | awk  -F = '/POSTGRESQL_ADDON_USER/ { print $2}'

Before starting the build, we need to configure two options in the Console. Tick the Enable dedicated build instance box because the Keycloak build needs more memory. Also tick the Sticky sessions box because it is necessary if you need to scale horizontally. To do that you have to go on the WebConsole, in your application, in the Information tab and tick the previously mentioned checkboxs.

You should now be ready to deploy :)

Deploy

Deploying with Clever Cloud is the easiest part. Simply run clever deploy and see the logs unfold before your eyes. Go ahead and test it by running clever open. Make sure you are using https while browsing the site. The default login and password are the one you set in the environment variable.

Now everything should work smoothly. What if you need to scale out your application? Let's say you want to have 2 keycloak instances. This can be configured like this:clever scale --instances 2

If you are unsure of the traffic you will get, you can configure a minimum and a maximum of instaces like this: clever scale --min-instances 2 --max-instances 5

Geoffroy Couprie is a consultant in software security and a independant developer. After testing Clever Cloud for a while, he challenged himself trying to run Smalltalk on our PaaS. Here's the recap of his findings.

The Smalltalk world offers a radically different way to create and run software, and I have always loved to tinker with it. Thanks to the recent work around Docker at Clever Cloud, it is now possible to run Pharo Smalltalk apps, even Seaside ones, on this PaaS.

Thinking in Smalltalk

One of the most interesting features of Smalltalk is the image, which is a file containing a list of serialized objects. When you start your virtual machine, you load the image. When you stop, you serialise everything: classes, methods, instances of classes, windows, even running web servers. And when you start, you get back your environment in the same state. Even writing code is different: you are not editing a file, you are editing the implementation of a method, serialised like everything else in the image. That way, you can modify code while it is running easily.

The traditional method for deploying a web server consists in preparing the image with the code, and uploading the whole image on the server. This is at odds with deployment process at Clever Cloud, based on a simple Git push. So it requires a few steps.

Docker

Thanks to the recent developments around Docker support, it is now possible to run any language or platform on these servers. So I prepared two images, one to install Pharo Smalltalk on an archlinux Docker container, and the other, based on the first, to install the Seaside web framework.

There is nothing tricky in the first image, except needing to install lib32-zlib, lib32-ncurses and lib32-bzip2 to run the 32 bits VM on a 64 bits CPU.

The second image runs a .st file to download Seaside, remove default Seaside apps and deactivate the debug bar:

Gofer new
url:'http://www.smalltalkhub.com/mc/Seaside/MetacelloConfigurations/main';
package: 'ConfigurationOfSeaside3';
load.
((Smalltalk at: #ConfigurationOfSeaside3) project version: #stable) load.

WAAdmin applicationDefaults removeParent: WADevelopmentConfiguration instance.
WADispatcher default handlers keys do:[:name | WAAdmin unregister:name].
Smalltalk snapshot: true andQuit: true.

Now, we have an image ready for deployment, and usable for all the future Seaside projects.

Preparing the code for deployment

We could save the image in a git repository, and push the whole file to Clever Cloud, but that would be too easy. What if we could send just the required code through git? Here comes FileTree, a library pre-installed in Pharo, that you can use to export code from the image and add it to a Git repository.

First, let's get some code to deploy. I will spare you the details, just get the WebCounter example from the Seaside book, it is doable under 10 minutes.

Done? Alright. Choose a folder that will contain the code you will push to the server, and git init in that folder. Now open the Monticello browser, add a new repository, select "filetree://" then choose your git folder.

Now select your WebCounter package in the Monticello browser, and save the code.

It should now appear in file form in the git folder:

$ tree .
.
└── WebCounter.package
    ├── WebCounter.class
    │   ├── README.md
    │   ├── instance
    │   │   ├── decrease.st
    │   │   ├── increase.st
    │   │   ├── initialize.st
    │   │   └── renderContentOn..st
    │   ├── methodProperties.json
    │   └── properties.json
    ├── monticello.meta
    │   ├── categories.st
    │   ├── initializers.st
    │   ├── package
    │   └── version
    └── properties.json

Loading the code

Now that we have an export of the Seaside component, we will create a Docker image to load the code. First, we need a small script to give the virtual machine at startup, to load the code and run it:

"this uses FileTree to load back the code from the /home/deploy folder"
(MCFileTreeRepository new directory: '/home/deploy' asFileReference) packageDescriptionsFromReadableFileNames  do:
  [:name || version |
  version := (MCFileTreeRepository new directory: '/home/deploy' asFileReference) versionFromFileNamed: name first, '.package'.
  [version load ]
        on: MCMergeOrLoadWarning
        do: [ :ex | [ ex load  ] on: MCNoChangesException do: [] ] ].

FileStream stdout nextPutAll: 'WebCounter installed'; lf.

"the Clever Cloud platform expects the app to listen on the 8080 port"
ZnZincServerAdaptor startOn: 8080.

"Register the code we just loaded on the /webcounter address"
WAAdmin register: WebCounter asApplicationAt: 'webcounter'.

Save that code as seaside.st, then we will create the Dockerfile to make it work on the server:

# -*- sh -*-
FROM geal/archlinux-seaside
MAINTAINER Geoffroy Couprie, contact@geoffroycouprie.com

ADD . /home/deploy

EXPOSE 8080

CMD ./pharo Pharo.image ./deploy/seaside.st

It reuses the archlinux-seaside image I prepared previously, copies the code from the repository in /home/deploy, then starts the image with the code loading script.

With this, you can build and run the image to test it:

$ docker build -t "geal/seaside-example" .
$ docker run -t -i -p 8080:8080 geal/seaside-example /bin/bash
[root@8e726df1bf4e home]# ./pharo Pharo.image ./deploy/seaside.st

UndefinedObject>>DoIt (WebCounter is Undeclared)
WebCounter installed

If you are on Linux, the website will be available on http://localhost:8080/webcounter. If you use OS X, run boot2docker ip, then access the server at http://<virtual machine IP>:8080/webcounter.

Creating the app on Clever Cloud and deploying

Go to https://console.clever-cloud.com, create a new application of type Docker, then get the git URL for your app, and do in your repository:

$ git remote add clever git+ssh://git@push.par.clever-cloud.com/<your app id>.git
$ git push clever master

And that's it! You can now access the Seaside component at http://<your_app_id>.cleverapps.io/webcounter.

At each new version of the code, export it to Git then push again, and the platform will redeploy everything automatically, rebuilding the Docker containers and the Pharo images. Now, you just need to add a few components to store state, like a database or S3 component, and you are good to go!

All the code is available on Github if you need to play with it:

• Archlinux Docker images
• WebCounter loaded with Docker, also contains an example for a web application using the Zinc server directly
• The example is currently running at http://pharo-seaside.cleverapps.io/webcounter

Why docker support is important for Clever Cloud users?

Has Docker become Clever Cloud's tech core?

How does it work?

Security

Performances

Virtual Machines you said? No chance, you'll get no perfs from it, Monsieur.

How to get started?