> For the complete documentation index, see [llms.txt](https://stablebuild.gitbook.io/stablebuild-documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://stablebuild.gitbook.io/stablebuild-documentation/docs/fr/pinning-your-first-container.md). # Épingler votre premier conteneur Dans [Pourquoi StableBuild ?](/stablebuild-documentation/docs/fr/why-stablebuild.md), nous avons examiné un Dockerfile typique et montré à quel point il dépend de services et de dépôts instables, qui peuvent casser votre build à tout moment. Pour rappel, voici ce Dockerfile : ```docker # Base ce Dockerfile sur Ubuntu 20.04 FROM ubuntu:20.04 # Ne demande pas de confirmation à l'installation des paquets ARG DEBIAN_FRONTEND=noninteractive # Installe quelques paquets système RUN apt update && apt install -y curl software-properties-common # Récupère une version plus récente de Python depuis le PPA Deadsnakes RUN add-apt-repository -y ppa:deadsnakes/ppa && \ apt update && \ apt install -y python3.9 python3.9-distutils # Installe pip (le gestionnaire de paquets Python) RUN curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \ python3.9 get-pip.py # Installe un paquet Python avec pip RUN pip3 install onnx==1.14.0 ``` Rendons ce conteneur déterministe et stable avec StableBuild ! ### Créer un compte StableBuild Rendez-vous d'abord sur et inscrivez-vous (un forfait Community gratuit est disponible). Vous arrivez alors sur le tableau de bord :

Le tableau de bord donne accès à tous les miroirs et dépôts StableBuild, à la gestion des utilisateurs et des clés, ainsi qu'aux informations de facturation. ### Épingler l'image de base La première ligne de notre Dockerfile est la suivante : ``` FROM ubuntu:20.04 ``` Cette image de base sera écrasée sur Docker Hub à chaque publication d'une nouvelle version d'Ubuntu 20.04, et elle pourrait même être supprimée du registre, ce qui rendrait vos builds non déterministes ou les casserait. Pour épingler cette image, rendez-vous sur **Tableau de bord > Miroir Docker**. Vous y trouverez le serveur de miroir Docker propre à votre compte, que vous pouvez placer en préfixe de n'importe quel `FROM` de votre Dockerfile.

Il est vivement recommandé d'utiliser également un tag plus précis, lorsqu'il en existe un. `ubuntu:20.04` est mis à jour très souvent, mais des instantanés précis d'Ubuntu 20.04 sont publiés sur Docker Hub sous le tag `focal-*`. En épinglant non pas `ubuntu:20.04` mais par exemple `focal-20231128` (la version du 28/11/2023 d'Ubuntu 20.04), vous pourrez passer à une version plus récente d'Ubuntu en cas de besoin, sans avoir à supprimer l'image épinglée dans StableBuild. Modifiez donc votre Dockerfile comme suit : ```docker FROM your-prefix.dockermirror.stablebuild.com/ubuntu:focal-20231128 ``` Puis reconstruisez le conteneur. À la première construction, nous récupérerons l'image `ubuntu:focal-20231128` depuis Docker Hub (toutes les architectures, pas seulement celle pour laquelle vous construisez) et nous la stockerons dans votre propre cache StableBuild. À partir de là, cette image est immuable. Vous obtiendrez toujours la même image de base, même si l'image en amont est mise à jour ou supprimée. Après un premier téléchargement, le tableau de bord se met à jour :

L'image de base est désormais en cache dans StableBuild

Si vous avez un jour besoin de retirer l'image du cache (par exemple parce qu'il vous faut une image Ubuntu 20.04 plus récente), vous pouvez le faire depuis « Tags en cache ». ### Épingler les paquets du dépôt de paquets Ubuntu et d'autres PPA Notre Dockerfile continue ainsi :

# Installer quelques paquets système
RUN apt update && apt install -y curl software-properties-common

# Il nous faut une version plus récente de Python, récupérons-la depuis le PPA Deadsnakes
RUN add-apt-repository -y ppa:deadsnakes/ppa && \
    apt update && \
    apt install -y python3.9 python3.9-distutils

Nous installons ici quelques paquets depuis le dépôt de paquets Ubuntu et depuis le PPA deadsnakes, mais ces paquets peuvent changer à tout moment, tant dans leur version que dans leur disponibilité. Pour les épingler, rendez-vous sur **Tableau de bord > Dépôt Ubuntu**. Ensuite : 1. Téléchargez `sb-apt.sh`, un script shell qui configure le dépôt (vous l'exécuterez depuis votre conteneur), et placez-le à côté de votre Dockerfile. 2. Choisissez une date d'épinglage. Nous réalisons chaque jour une copie complète de l'intégralité du dépôt de paquets Ubuntu (ainsi que Debian et Alpine), tous paquets inclus, et de nombreux PPA : vous épinglez donc sur une date, celle à laquelle nous avons réalisé la copie. Pour un nouveau conteneur, conservez simplement la valeur par défaut, à savoir la date du dernier miroir. 3. Sélectionnez les dépôts de paquets à charger. Ici « Ubuntu » et « Deadsnakes (Python) ».\ \ *Remarque : s'il vous faut un autre PPA, écrivez-nous et nous l'ajouterons à StableBuild.*

Épinglage des paquets du dépôt de paquets Ubuntu (et d'autres PPA)

Suivez ensuite les instructions de l'étape 4 pour mettre à jour votre Dockerfile, qui devient : ```docker # Base ce Dockerfile sur Ubuntu 20.04 (version du 28/11/2023) FROM your-prefix.dockermirror.stablebuild.com/ubuntu:focal-20231128 ARG SB_API_KEY=your-prefix ARG APT_PIN_DATE=2023-12-07T10:40:01Z COPY ./sb-apt.sh /opt/sb-apt.sh RUN bash /opt/sb-apt.sh load-apt-sources ubuntu deadsnakes # Installe quelques paquets système RUN apt update && apt install -y curl software-properties-common # Récupère une version plus récente de Python depuis le PPA Deadsnakes (plus besoin d'ajouter le dépôt à la main) RUN apt update && apt install -y python3.9 python3.9-distutils ``` Reconstruisez le conteneur : les paquets sont désormais récupérés depuis le miroir StableBuild.

Les paquets sont désormais récupérés depuis le miroir StableBuild

### Épingler n'importe quel fichier trouvé sur Internet Notre Dockerfile continue ainsi : ```docker # Installe pip (le gestionnaire de paquets Python) RUN curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \ python3.9 get-pip.py ``` Nous téléchargeons ici un fichier depuis Internet, puis nous l'installons. Pour épingler n'importe quelle URL, rendez-vous sur **Tableau de bord > Miroir de fichiers**.

Vous y trouverez un préfixe à placer devant n'importe quelle URL, ce qui met automatiquement le fichier en cache et le rend immuable. Le fichier apparaît ensuite sous « Fichiers en cache », et c'est exactement le même fichier qui sera renvoyé aux requêtes suivantes :

Consultation des fichiers en cache dans la clé de cache « my-first-tutorial ».

Pour la plupart des fichiers, cela suffit. Certains scripts téléchargent toutefois d'autres fichiers à l'exécution : pour ceux-là, il faut également réécrire les URL contenues dans le script, ou mettre en place un proxy HTTP. C'est justement le cas de `get-pip.py` : ce n'est qu'un script d'amorçage, qui télécharge le véritable paquet pip depuis le registre PyPI. Heureusement, get-pip permet d'indiquer le miroir PyPI avec l'option `-i`, et nous pouvons utiliser le [miroir PyPI](/stablebuild-documentation/docs/fr/mirrors-and-caches/pypi-mirror.md) de StableBuild pour épingler le paquet réellement téléchargé (voir « Épingler des paquets Python » ci-dessous). Votre Dockerfile devient : ```docker # Base ce Dockerfile sur Ubuntu 20.04 (version du 28/11/2023) FROM your-prefix.dockermirror.stablebuild.com/ubuntu:focal-20231128 ARG SB_API_KEY=your-prefix ARG APT_PIN_DATE=2023-12-07T10:40:01Z COPY ./sb-apt.sh /opt/sb-apt.sh RUN bash /opt/sb-apt.sh load-apt-sources ubuntu deadsnakes # Installe quelques paquets système RUN apt update && apt install -y curl software-properties-common # Récupère une version plus récente de Python depuis le PPA Deadsnakes (plus besoin d'ajouter le dépôt à la main) RUN apt update && apt install -y python3.9 python3.9-distutils # Installe pip (le gestionnaire de paquets Python) en téléchargeant get-pip.py depuis # le cache de fichiers, puis en installant le véritable paquet depuis le miroir PyPI RUN curl https://your-prefix.httpcache.stablebuild.com/my-first-tutorial/https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \ python3.9 get-pip.py -i https://your-prefix.pypimirror.stablebuild.com/2023-12-07/ ``` ### Épingler des paquets Python Enfin, notre Dockerfile se termine par : ```docker # Installe un paquet Python avec pip RUN pip3 install onnx==1.14.0 ``` On croirait que cette ligne épingle le paquet onnx à une version exacte, mais onnx a lui-même des dépendances non épinglées. Pour épingler correctement le paquet et toutes ses sous-dépendances, rendez-vous sur **Tableau de bord > Miroir PyPI**. Vous devez y choisir une date d'épinglage. Comme pour le dépôt de paquets Ubuntu / Debian / PPA, nous créons chaque jour un miroir de l'intégralité du registre PyPI : vous pouvez donc installer la liste complète des paquets telle qu'elle existait à un instant précis. S'il s'agit d'un nouveau conteneur, conservez la valeur par défaut. Les versions plus anciennes du miroir PyPI sont toutefois très utiles pour ressusciter d'anciens exemples Python (voir [Miroir PyPI > Faire fonctionner des exemples Python plus anciens](/stablebuild-documentation/docs/fr/mirrors-and-caches/pypi-mirror.md#faire-fonctionner-des-exemples-python-plus-anciens)).

Épinglage de paquets Python avec le miroir PyPI de StableBuild

Pour épingler, il suffit de modifier la ligne `pip3 install` afin qu'elle pointe vers le miroir StableBuild. Votre Dockerfile devient : ```docker # Base ce Dockerfile sur Ubuntu 20.04 (version du 28/11/2023) FROM your-prefix.dockermirror.stablebuild.com/ubuntu:focal-20231128 ARG SB_API_KEY=your-prefix ARG APT_PIN_DATE=2023-12-07T10:40:01Z COPY ./sb-apt.sh /opt/sb-apt.sh RUN bash /opt/sb-apt.sh load-apt-sources ubuntu deadsnakes # Installe quelques paquets système RUN apt update && apt install -y curl software-properties-common # Récupère une version plus récente de Python depuis le PPA Deadsnakes (plus besoin d'ajouter le dépôt à la main) RUN apt update && apt install -y python3.9 python3.9-distutils # Installe pip (le gestionnaire de paquets Python) en téléchargeant get-pip.py depuis # le cache de fichiers, puis en installant le véritable paquet depuis le miroir PyPI RUN curl https://your-prefix.httpcache.stablebuild.com/my-first-tutorial/https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \ python3.9 get-pip.py -i https://your-prefix.pypimirror.stablebuild.com/2023-12-07/ # Installe un paquet Python avec pip RUN pip3 install \ -i https://your-prefix.pypimirror.stablebuild.com/2023-12-07/ \ install onnx==1.14.0 ``` Reconstruisez le conteneur, et c'est terminé. Ce conteneur est maintenant entièrement épinglé : il installera toujours la même version de l'OS, la même liste de paquets et les mêmes dépendances Python. 🎉 ### Astuces et conseils #### Journaux de trafic Tout ce qui est récupéré via StableBuild est soumis à des limites de trafic (ou à des frais de dépassement sur les forfaits payants ; votre quota est indiqué sur le tableau de bord). Un aperçu du trafic de la période de facturation en cours est affiché sur le tableau de bord ; pour consulter les journaux de trafic détaillés, rendez-vous sur **Tableau de bord > Facturation > Journaux de consommation bruts**. Vous y trouverez tous les journaux de trafic bruts, avec le service, l'adresse IP et la clé d'API utilisés :

Journaux de trafic bruts dans StableBuild

#### Gardez vos clés confidentielles L'URL d'un service (par exemple dans `https://your-prefix.pypimirror.stablebuild.com/2023-12-07/`) sert à vous authentifier auprès de StableBuild et à facturer votre compte. Gardez cette URL confidentielle et ne la publiez pas dans des dépôts publics : n'importe qui pourrait alors télécharger depuis StableBuild avec votre compte. Si vous constatez des pics de trafic inhabituels, consultez les journaux de consommation bruts pour vérifier qu'une clé n'a pas fuité. Vous pouvez renouveler vos clés via **Tableau de bord > Clés**. Pour rendre un dépôt public stable et déterministe, créez plutôt une [clé d'API publique](/stablebuild-documentation/docs/fr/product/public-api-keys.md). Elle est en lecture seule et ne sert que les dépendances que vous avez autorisées.