Cette méthode convient pour installer de petits ensembles de paquets comme des fichiers .deb, .rpm, .tar.gz, .whl, etc.

Exemple de structure de répertoire :

mon-image/
├── Dockerfile
└── paquets/
    ├── nginx_1.24.0.deb
    ├── libxxx.deb
    └── application.tar.gz

Exemple de Dockerfile pour Ubuntu/Debian:

FROM ubuntu:22.04

COPY paquets/ /tmp/paquets/

RUN dpkg -i /tmp/paquets/*.deb || apt-get install -f -y \
    && rm -rf /tmp/paquets/*

Pour CentOS/Rocky/RHEL:

FROM rocky:9

COPY paquets/ /tmp/paquets/

RUN dnf install -y /tmp/paquets/*.rpm \
    && rm -rf /tmp/paquets/*

Pour Python avec des paquets wheel hors ligne:

FROM python:3.11

COPY roues/ /tmp/roues/
COPY requirements.txt /tmp/

RUN pip install --no-index --find-links=/tmp/roues -r /tmp/requirements.txt \
    && rm -rf /tmp/roues

Solution 2 : Déployer une source logicielle interne

Cette option est adaptée pour des environnements avec de nombreuses dépendances nécessitant une maintenance à long terme. Par exemple, déployer une source interne pour:

• APT (Ubuntu/Debian)
• YUM/DNF (CentOS/Rocky/RHEL)
• PIP (Python)
• NPM (Node.js)
• Maven
• Registre Docker

Exemple pour Ubuntu/Debian:

FROM ubuntu:22.04

RUN sed -i 's|http://archive.ubuntu.com/ubuntu|http://source-apt-interne/ubuntu|g' /etc/apt/sources.list \
    && apt-get update \
    && apt-get install -y curl vim nginx \
    && rm -rf /var/lib/apt/lists/*

Pour CentOS/Rocky:

FROM rocky:9

COPY interne.repo /etc/yum.repos.d/interne.repo

RUN dnf install -y nginx curl vim \
    && dnf clean all

Pour PIP Python:

FROM python:3.11

COPY requirements.txt /app/

RUN pip install -i http://source-pip-interne/simple --trusted-host source-pip-interne \
    -r /app/requirements.txt

Solution 3 : Télécharger les dépendances hors ligne sur une machine externe

Téléchargement sur une machine externe:

apt-get download curl vim nginx

Ou télécharger des roues Python:

pip download -r requirements.txt -d roues/

Copier ces fichiers vers l'environnement interne et utiliser dans le Dockerfile:

COPY roues/ /tmp/roues/
RUN pip install --no-index --find-links=/tmp/roues -r requirements.txt

Solution 4 : Construire l'image hors ligne puis l'importer en interne

Construction hors ligne:

docker build -t monappli:1.0 .
docker save monappli:1.0 -o monappli_1.0.tar

Copier vers l'environnement interne et charger:

docker load -i monappli_1.0.tar

Cette méthode convient lorsque les machines internes ne peuvent pas accéder à aucune source et sont uniquement utilisées pour exécuter des images.

Pratiques recommandées

• Pour de petits ensembles de paquets: inclure les paquets dans le répertoire de construction et les copier.
• Pour une utilisation à long terme dans une entreprise: déployer une source APT/YUM/PIP/NPM/Maven interne ainsi qu'un registre Docker interne.
• Pour des environnements entièrement isolés: construire l'image hors ligne, l'exporter avec docker save, puis l'importer avec docker load.

Un modèle Dockerfile typique hors ligne pour Ubuntu:

FROM ubuntu:22.04

COPY paquets/ /tmp/paquets/

RUN dpkg -i /tmp/paquets/*.deb || true \
    && apt-get install -f -y \
    && rm -rf /tmp/paquets/*

Notez que apt-get install -f pourrait toujours nécessiter l'accès à une source logicielle. Si totalement hors ligne, tous les paquets dépendants doivent être préparés.

Téléchargement ciblé de paquets Python pour une version spécifique

Supposons que votre conteneur cible soit:

• Python 3.10
• Linux x86_64
• CPython

Commande pour télécharger:

python -m pip download \
  -r requirements.txt \
  -d roues/ \
  -i http://pypi.societe.com/simple \
  --trusted-host pypi.societe.com \
  --only-binary=:all: \
  --python-version 310 \
  --implementation cp \
  --abi cp310 \
  --platform manylinux2014_x86_64

Explications des paramètres:

• -d roues/: Télécharger dans le répertoire roues
• -i: Spécifier la source PyPI interne de la société
• --python-version 310: Version cible de Python est 3.10
• --implementation cp: CPython
• --abi cp310: ABI CPython pour Python 3.10
• --platform manylinux2014_x86_64: Plateforme cible Linux x86_64
• --only-binary=:all:: Télécharger uniquement les roues, pas les sources

Correspondance des versions Python

Exemples courants:

• Python 3.8 → --python-version 38 --abi cp38
• Python 3.9 → --python-version 39 --abi cp39
• Python 3.10 → --python-version 310 --abi cp310
• Python 3.11 → --python-version 311 --abi cp311
• Python 3.12 → --python-version 312 --abi cp312

Téléchargement après vérification de la version Python

Si la machine de téléchargement et le conteneur cible ont la même version de Python (par exemple, Python 3.10):

python3.10 -m pip download \
  -r requirements.txt \
  -d roues/ \
  -i http://pypi.societe.com/simple \
  --trusted-host pypi.societe.com

Installation hors ligne dans le Dockerfile

Structure du répertoire:

projet/
├── Dockerfile
├── requirements.txt
└── roues/
    ├── xxx.whl
    ├── yyy.whl
    └── ...

Dockerfile:

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
COPY roues/ /roues/

RUN pip install --no-index --find-links=/roues -r requirements.txt

Gestion des erreurs "No matching distribution found"

Trois raisons courantes:

1. Le source interne n'a pas le bon fichier wheel pour la version cible de Python.
2. La plateforme spécifiée est incorrecte.
3. Certains paquets n'ont pas de fichier wheel, seulement des sources.

Solutoin pour les paquets sans fichier wheel:

python -m pip wheel \
  -r requirements.txt \
  -w roues/ \
  -i http://pypi.societe.com/simple \
  --trusted-host pypi.societe.com

Puis installer hors ligne dans le Dockerfile.

Processus recommandé

Pour un environnement interne d'entreprise:

1. Déterminer la version Python de l'image cible.
2. Télécharger les fichiers wheel compatibles avec cette version.
3. Installer hors ligne dans le Dockerfile.