Aller au contenu
DevSecOps Logo DevSecOps Logo DevSecOps
Docs
Blog
Blog

Colima l'alternative à Docker Desktop sur MacOS

L’installation de Docker sur macOS repose généralement sur Docker Desktop, un outil officiel offrant une interface graphique et une intégration fluide. Cependant, son utilisation présente des inconvénients comme une consommation de ressources élevée et des restrictions de licence, notamment pour les entreprises.

Pour répondre à ces besoins, il est possible d’utiliser des alternatives comme Colima, un outil léger et open-source, qui permet de configurer Docker sans Docker Desktop.

Présentation de Colima

Colima est une alternative légère à Docker Desktop qui permet d’exécuter des environnements de conteneurs Docker sur macOS, ainsi que sur Linux. Conçu pour être compatible avec les conteneurs Docker et Kubernetes, Colima repose sur Lima, un gestionnaire de machines virtuelles et utilise une VM Linux optimisée pour la gestion de conteneurs.

Ce qui distingue Colima, c’est son efficacité en termes de performance et son intégration simple avec les workflows Docker existants. Puisqu’il s’exécute en arrière-plan via une VM, il n’impose pas les mêmes contraintes en matière de licence ou de performance que Docker Desktop. Colima est particulièrement apprécié pour sa flexibilité, permettant aux utilisateurs d’ajuster la configuration de la VM (par exemple, en attribuant des ressources CPU et RAM spécifiques), ce qui est idéal pour des environnements de développement personnalisés.

Prérequis pour l’installation

Avant de commencer l’installation de Docker sans Docker Desktop avec Colima, quelques prérequis sont nécessaires. Vous devez tout d’abord disposer de Homebrew, un gestionnaire de paquets incontournable sur macOS, qui facilitera l’installation des outils. Si vous ne l’avez pas encore, vous pouvez l’installer avec la commande suivante :

Terminal window
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Ensuite, assurez-vous d’avoir une version récente de macOS, avec Git installé pour récupérer certains des paquets ou scripts nécessaires. Vérifiez cela en exécutant :

Terminal window
git --version
git version 2.46.0

Si Git n’est pas installé, utilisez Homebrew :

Terminal window
brew install git

Ces éléments vous prépareront pour l’installation des outils Docker et de Colima, garantissant une configuration stable et sans conflits.

En plus de Homebrew et Git, il est essentiel d’installer la CLI Docker pour interagir avec Docker sans Docker Desktop. Docker CLI est le client qui vous permet de gérer vos conteneurs, images et volumes directement depuis le terminal.

Pour installer Docker CLI via Homebrew, exécutez la commande suivante :

Terminal window
brew install docker

Une fois installé, vous pouvez vérifier son bon fonctionnement en exécutant :

Terminal window
docker --version
Docker version 27.2.0, build 3ab4256958

Cette commande doit renvoyer la version de Docker CLI installée, garantissant que votre environnement est prêt pour la configuration avec Colima.

Installation de Colima

L’installation de Colima sur macOS est simple grâce à Homebrew, le gestionnaire de paquets. Pour commencer, ouvrez votre terminal et exécutez la commande suivante :

Terminal window
brew install colima

Cela télécharge et installe Colima ainsi que ses dépendances. Une fois l’installation terminée, vous pouvez vérifier que Colima a été installé correctement en exécutant :

Terminal window
colima --version
colima version 0.7.5

Cela vous affiche la version installée de Colima, confirmant ainsi que le logiciel est prêt à être utilisé. À ce stade, Colima est installé, mais il n’est pas encore actif.

Pour démarrer Colima avec Docker activé, utilisez la commande suivante :

Terminal window
colima start

Cette commande démarre une machine virtuelle avec Docker installé, prête à exécuter des conteneurs. Vous pouvez également personnaliser la configuration en ajustant les ressources allouées, comme le nombre de CPU ou la quantité de mémoire. Par exemple, pour attribuer deux CPU et 4 Go de RAM :

Terminal window
colima start --with-docker --cpu 2 --memory 4

Cela vous permet d’optimiser Colima en fonction de vos besoins spécifiques en développement. Une fois démarré, vous pouvez vérifier que Docker fonctionne correctement en exécutant :

Terminal window
docker ps
CONTAINER ID   IMAGE                   COMMAND           CREATED             STATUS                       PORTS                                       NAMES

Cette commande confirmera que Colima est bien configuré avec Docker.

Vous pouvez aussi utiliser cette commande :

Terminal window
colima start --edit
INFO[0000] vscode detected, editing in vscode

Cela ouvrira une fenêtre dans votre éditeur de code, vous permettant d’ajouter beaucoup de paramètres.

Installation du plugin Docker Compose

Pour installer le plugin docker-compose manuellement, voici les étapes à suivre.

Tout d’abord, définissez le chemin de la configuration Docker et créez le dossier pour les plugins CLI :

Terminal window
DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
mkdir -p $DOCKER_CONFIG/cli-plugins

Ensuite, téléchargez la version la plus récente ↗ de docker-compose pour macOS (architecture ARM) :

Terminal window
curl -SL https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-darwin-aarch64 -o $DOCKER_CONFIG/cli-plugins/docker-compose

Rendez le fichier exécutable :

Terminal window
chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose

Pour vous assurer que la variable DOCKER_CONFIG est définie à chaque session, ajoutez-la à votre fichier bashrc ou zshrc, selon le shell que vous utilisez.

Pour bash :

Terminal window
echo 'export DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}' >> ~/.bashrc
source ~/.bashrc

Pour zsh :

Terminal window
echo 'export DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}' >> ~/.zshrc
source ~/.zshrc

Cela garantit que votre environnement est correctement configuré pour utiliser docker-compose avec Colima. Vous pouvez vérifier l’installation avec :

Terminal window
docker compose version
Docker Compose version v2.29.2

Installation du plugin Buildkit

On reprend le même processus. On vérifie dans les releases du projet, la dernière version du plugin et on l’installe :

Terminal window
curl -SL https://github.com/docker/buildx/releases/download/v0.17.0/buildx-v0.17.0.darwin-arm64 -o $DOCKER_CONFIG/cli-plugins/docker-buildx
chmod +x $DOCKER_CONFIG/cli-plugins/docker-buildx

On vérifie que le plugin est correctement installé en utilisant un Dockerfile :

Terminal window
export DOCKER_BUILDKIT=1
docker build .
[+] Building 0.4s (7/7) FINISHED                                            docker:colima
 => [internal] load build definition from Dockerfile                                 0.0s
 => => transferring dockerfile: 255B                                                 0.0s
 => [internal] load metadata for docker.io/library/alpine:3.18.4                     0.4s
 => [internal] load .dockerignore                                                    0.0s
 => => transferring context: 2B                                                      0.0s
 => [1/3] FROM docker.io/library/alpine:3.18.4@sha256:eece025e432126ce23f223450a032  0.0s
 => CACHED [2/3] RUN apk update &&     apk upgrade                                   0.0s
 => CACHED [3/3] RUN apk add --no-cache nginx                                        0.0s
 => exporting to image                                                               0.0s
 => => exporting layers                                                              0.0s
 => => writing image sha256:9ac30a0576abfc050b0a29e6c3357df3fc4defa30c6b8b1e49a12fa  0.0s

Si BuildKit est actif, vous verrez des messages spécifiques au processus BuildKit dans la sortie comme ci-dessus.

Construction d’images pour d’autres plateformes

Docker Buildx est un outil qui permet de construire des images Docker compatibles avec plusieurs architectures, comme amd64 et arm64. Cela est particulièrement utile si vous souhaitez déployer vos conteneurs sur des plateformes ayant des processeurs différents.

Il faut commencer par créer builder utilisant le driver docker-container :

Terminal window
docker buildx create --driver docker-container --bootstrap --name mybuilder

Vérifions que l’arcchitecture amd64 est bien prise en charge par le builder :

Terminal window
docker buildx ls
NAME/NODE        DRIVER/ENDPOINT    STATUS    BUILDKIT   PLATFORMS
mybuilder        docker-container
 \_ mybuilder0    \_ colima         running   v0.15.2    linux/arm64, linux/amd64, linux/amd64/v2

Pour créer une image compatible avec l’architecture amd64 et arm64), utilisez la commande suivante :

Terminal window
docker buildx build --platform linux/amd64 -t monimage:0.1 .

Vérifions notre image :

Terminal window
docker images
REPOSITORY      TAG               IMAGE ID       CREATED         SIZE
monimage        0.1               5074f8f0067c   5 minutes ago   19.7MB


docker image inspect 5074f8f0067c


[
    {
        "Id": "sha256:5074f8f0067c52ba6a32c587fdb06d3e64b2acfcf2130c7129c5c5d3cf3f94b3",
        "RepoTags": [
            "monimage:0.1",
            "monimage:multiarch",
            "my-image:0.1"
        ],
        "RepoDigests": [],
        "Parent": "",
        "Comment": "buildkit.dockerfile.v0",
        "Created": "2024-09-11T16:39:38.889822258+02:00",
        "DockerVersion": "",
        "Author": "",
        "Config": {
            "Hostname": "",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {
                "80/tcp": {}
            },
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "nginx",
                "-g",
                "daemon off;"
            ],
            "ArgsEscaped": true,
            "Image": "",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": null
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 19695580,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/c9m6a0y9hldtskhnbb39x6hvf/diff:/var/lib/docker/overlay2/mz7g8vx7xlimed53o3664clqx/diff:/var/lib/docker/overlay2/ec21c3e2eeef50044d9d8269987ca830947c6c55c472b706fad98e2b5477d06f/diff",
                "MergedDir": "/var/lib/docker/overlay2/kl1cw9vcdlmp1qwug912rmxsw/merged",
                "UpperDir": "/var/lib/docker/overlay2/kl1cw9vcdlmp1qwug912rmxsw/diff",
                "WorkDir": "/var/lib/docker/overlay2/kl1cw9vcdlmp1qwug912rmxsw/work"
            },
            "Name": "overlay2"
        },
        "RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:cc2447e1835a40530975ab80bb1f872fbab0f2a0faecf2ab16fbbb89b3589438",
                "sha256:58fd0fd92ce0651a0a3a5812eb66dd38fc2ec8029705c8fc0161c36353ef163f",
                "sha256:93649e3d518fd9f36439490d0a5be962bb9739e9c72ff31d88e082a9becd45e6",
                "sha256:e1cfefbd800c00b4b3f7dff3b62bb98b64b20ab7f462725b3c3213a3940a6f51"
            ]
        },
        "Metadata": {
            "LastTagTime": "2024-09-11T16:45:29.366525913+02:00"
        }
    }
]

On obtiens bien une image linux pour architecture amd64. Reste plus qu’à s’en servir.

Et kubernetes

Nous allons créer une autre instance colima avec un peu plus de ressources :

Terminal window
colima start --kubernetes kube --cpu 4 --memory 8

Une fois provisionné, il suffit d’utiliser la commande kubectl habituelle :

Terminal window
kubectl get nodes
NAME          STATUS   ROLES                  AGE   VERSION
colima-kube   Ready    control-plane,master   29s   v1.30.2+k3s1

Y’a plus qu’à !

N’oubliez d’arrêter votre instance pour libérer les ressources.

Terminal window
colima ls


PROFILE    STATUS     ARCH       CPUS    MEMORY    DISK     RUNTIME       ADDRESS
default    Running    aarch64    4       4GiB      60GiB    docker
kube       Running    aarch64    4       8GiB      60GiB    docker+k3s
Terminal window
colima stop kube

Conclusion

En remplaçant Docker Desktop par Colima sur macOS, vous gagnez en flexibilité tout en réduisant la consommation de ressources. Grâce à l’installation et à la configuration des plugins Compose et BuildKit, vous conservez l’essentiel des fonctionnalités de Docker, sans les contraintes imposées par Docker Desktop. Que ce soit pour des besoins de développement léger ou pour des environnements plus complexes, Colima vous offre une solution open-source efficace et performante. Maintenant que tout est configuré, vous pouvez pleinement profiter d’un environnement Docker optimisé pour macOS et même déployer des applications dans votre cluster kubernetes.

Plus d’infos