SAE exécute les applications sous forme d'images de conteneur. Si vous ne disposez pas d'une image existante, suivez les étapes ci-dessous pour en créer une et l'envoyer vers un registre d'images.
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
Docker installé et en cours d'exécution. Exécutez
docker --versionpour le vérifier.Un répertoire de projet contenant un artefact compilé (JAR, fichiers PHP, application Python ou ressources statiques).
Créer et envoyer une image de conteneur
Étape 1 : Créer un Dockerfile
Accédez à votre répertoire de projet et créez un fichier nommé Dockerfile. Les exemples ci-dessous couvrent Java, PHP, Python et Node.js.
Java
Structure des répertoires :
.
├── Dockerfile
├── target
│ └── my-app.jar # Compiled JAR — only this and the Dockerfile are needed to build the image
├── src
│ └── ...
└── pom.xml
Dockerfile :
# Use an Alpine-based OpenJDK 8 image — Alpine keeps the image size small
FROM openjdk:8-jdk-alpine
# Copy the compiled JAR into the image root
COPY ./target/my-app.jar /
# Start the application when the container launches
ENTRYPOINT ["java", "-jar", "/my-app.jar"]
Conseil : Pour les applications Java de production, privilégiez les builds multi-étapes afin de réduire la taille de l'image finale : effectuez la compilation dans une étape basée sur le JDK, puis copiez uniquement le fichier JAR dans une étape d'exécution basée sur le JRE.
PHP
Structure des répertoires :
.
├── Dockerfile
├── entrypoint.sh # Startup script that launches PHP-FPM and Nginx
├── php
│ ├── index.php
│ └── phpinfo.php
├── nginx
│ ├── nginx.conf
│ ├── conf.d
│ │ └── default.conf
│ ├── fastcgi_params
│ └── ...
Dockerfile :
# Use an Alpine-based PHP-FPM image — PHP-FPM handles PHP processing, Nginx handles HTTP
FROM php:8.2-fpm-alpine
# Install Nginx into the same container to serve as the HTTP frontend
RUN apk add --no-cache nginx
# Copy Nginx configuration files
COPY nginx/ /etc/nginx/
# Copy PHP application files to the web root
COPY php/ /var/www/html/
# Copy and enable the startup script
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
Script de démarrage (entrypoint.sh) :
#!/bin/sh
# Start PHP-FPM in the background so Nginx can forward PHP requests to it
php-fpm -D
# Verify PHP-FPM started successfully before launching Nginx
if ! pgrep "php-fpm" >/dev/null
then
echo "PHP-FPM failed to start!"
exit 1
fi
# Run Nginx in the foreground — the container stays alive as long as Nginx runs
nginx -g "daemon off;"
Python
Structure des répertoires :
.
├── Dockerfile
├── entrypoint.sh
├── my_app
│ ├── requirements.txt
│ ├── main.py
│ └── my_package
│ ├── __init__.py
│ └── ...
Dockerfile :
# Use the official Python 3.9 image
FROM python:3.9
# Copy the application code into the image
RUN mkdir -p /my_app
COPY my_app/ /my_app/
# Install Python dependencies declared in requirements.txt
RUN pip install -r /my_app/requirements.txt
# Copy and enable the startup script
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
Script de démarrage (entrypoint.sh) :
#!/bin/sh
# Start the Flask app using Gunicorn with 3 worker processes, listening on port 8080
# Flask and Gunicorn are declared as dependencies in requirements.txt
gunicorn -w 3 -b 0.0.0.0:8080 my_app.main:app
Node.js
Cet exemple concerne un projet frontend dont les ressources statiques sont servies par Nginx.
Structure des répertoires :
.
├── Dockerfile
├── nginx-conf
│ ├── nginx.conf
│ ├── conf.d
│ │ └── default.conf
│ └── ...
├── package.json
├── src
│ └── ...
└── dist # Static files generated by your build step (e.g., npm run build)
├── index.html
└── static
└── ...
Dockerfile :
# Use Nginx 1.22 as the base image — it provides the startup command, so no ENTRYPOINT is needed
FROM nginx:1.22
# Copy the built static files to Nginx's default serving directory
COPY ./dist /usr/share/nginx/html/
# Copy your Nginx configuration files
COPY ./nginx-conf /etc/nginx/
Exécutez votre étape de build (par exemple,npm run build) avant d'exécuterdocker build. Le répertoiredistdoit exister à la racine de votre projet.
Étape 2 : Construire l'image
docker build -t <image-name>:<image-tag> .
Exemple :
docker build -t my-app:1.0 .
Ne stockez pas de secrets (clés API, mots de passe ou identifiants d'accès) en dur dans votre Dockerfile à l'aide des instructions ENV ou ARG. Les valeurs transmises via les arguments de build peuvent apparaître dans l'historique de l'image.
Étape 3 : Envoyer l'image vers un registre
Envoyez l'image vers un registre d'images accessible par SAE. Si vous n'en possédez pas, utilisez Alibaba Cloud Container Registry (ACR) :
Étape 4 : Déployer sur SAE
Choisissez la méthode de déploiement en fonction de l'emplacement de stockage de votre image :
| Scénario | Méthode |
|---|---|
| L'image se trouve dans ACR sous le même compte Alibaba Cloud | Déployer en utilisant des images ACR du même compte |
| L'image se trouve dans ACR sous un compte Alibaba Cloud différent | Déployer en utilisant des images ACR inter-comptes |
| L'image se trouve dans un registre non-ACR | Déployer en utilisant des images d'un registre non-ACR |