Dockerisation d'une application Java garantit la cohérence, la portabilité, l'isolement et la préparation au nuage. 1. Préparez un pot autonome à l'aide de maven ou de gradle. 2. Créez un Dockerfile docker à plusieurs étapes à l'aide d'images minces ou distrodes, copiez le pot, définissez un utilisateur non racine, exposez le port 8080 et définissez le point d'entrée. 3. Sélectionnez l'image en évitant les versions racinaires, épinglant et en définissant des limites JVM comme -xmx512m et -xx: useContainersupport. 4. Construire et tester localement avec Docker Build et Docker Run. 5. Poussez vers un registre de conteneurs tels que Docker Hub ou AWS ECR après le marquage. 6. Déployer sur Kubernetes via le déploiement et le service YAMLS ou utilisez des services gérés comme Cloud Run ou ECS. 7. Automatiser avec CI / CD en utilisant des actions GitHub ou similaires, en s'appuyant sur la poussée et le déploiement après les tests. Les conseils finaux incluent la surveillance des ressources, les journaux de streaming, la mise en ?uvre de contr?les de santé et les configurations d'externalisation via des variables environnementales, ce qui se traduit par une application Java à cloud sécurisée, efficace et prête pour la production.

Dockerisation d'une application Java pour le déploiement cloud est un moyen commun et efficace d'assurer la cohérence entre les environnements, de simplifier la mise à l'échelle et de rationaliser les pipelines CI / CD. Voici comment faire les choses correctement - de la configuration aux considérations de déploiement.

? Pourquoi docker une application Java?

Avant de plonger, il aide à comprendre les avantages:

• Cohérence : même environnement du développement à la production.
• Portabilité : Exécutez n'importe où Docker s'exécute - Machines locales, VMS, Clusters Kubernetes.
• Isolement : les dépendances sont contenues; Non, cela ne fonctionne pas sur mes problèmes de machine.
• Prépare à Cloud : les principaux fournisseurs de cloud (AWS, GCP, Azure) prennent en charge les applications contenerisées nativement.

? ? étape 1: Préparez votre application Java

Assurez-vous que votre application peut être intégrée dans un pot autonome (de préférence un pot de graisse avec serveur intégré comme Spring Boot).

Par exemple, si vous utilisez Maven:

 Package Clean MVN

Cela génère un fichier JAR comme target/myapp-0.0.1.jar .

Assurez-vous que le pot comprend toutes les dépendances et dispose d'une entrée Main-Class appropriée dans son manifeste.

? étape 2: écrivez un dockerfile

Créez un Dockerfile dans la racine de votre projet:

 # Utilisez une image de base OpenJDK mince (préférez plusieurs étages ou distro pour la production)
De OpenJDK: 17-JDK-SLIM en tant que constructeur

# Définir le répertoire de travail
WorkDir / App

# Copiez d'abord les fichiers Maven (pour une meilleure mise en cache de couche)
Copier pom.xml.
Copier src ./src

# Construisez le pot
Exécutez le package MVN Clean -Dskiptests

# Deuxième étape: image d'exécution légère
De OpenJDK: 17-JRE-SLIM

WorkDir / App

# Copier le pot de l'étape du constructeur
Copier --From = Builder /App/target/*.jar app.jar

# Facultatif: Créer un utilisateur non racinaire pour la sécurité
Exécutez AddGroup --System Javauser && AddUser - System Javauser --Angroup Javauser
Utilisateur Javauser

# Expose Port (par exemple, 8080 pour Spring Boot)
Exposer 8080

# Exécutez l'application
EntryPoint ["java", "-jar", "app.jar"]

? Conseils :

• Utilisez des versions en plusieurs étapes pour réduire la taille finale de l'image.
• Préférez -jre sur -jdk dans l'étape d'exécution, sauf si vous avez besoin d'outils comme javac .
• évitez latest balises; Versions PIN pour la reproductibilité.

? étape 3: sécuriser et optimiser l'image

La sécurité et l'efficacité sont importantes dans le cloud:

• Utilisez des images de distro ( distro de Google) pour une surface d'attaque minimale:

   De gcr.io/distrolesless/java17-debian11
  Copier --From = Builder /App/target/app.jar /app.jar
  EntryPoint ["java", "-jar", "/app.jar"]

• Définir les limites de mémoire JVM appropriées pour les conteneurs:

   EntryPoint ["java", "-xmx512m", "-xx: useContainersupport", "-jar", "app.jar"]

• Ne vous exécutez pas en tant que racine ( USER javauser comme indiqué ci-dessus).

? étape 4: construire et tester localement

Construisez l'image:

 docker build -t my-java-app: 1.0.

Exécutez-le:

 Docker Run -P 8080: 8080 My-Java-App: 1.0

Tester les points de terminaison:

 Curl http: // localhost: 8080 / Health

Vérifiez les journaux, les performances et le comportement d'arrêt.

?? étape 5: Push to Container Registry

Pour déployer dans le cloud, poussez votre image vers un registre.

Exemples:

• Hub docker
• Amazon ECR
• Registre Google GCR / Artefact
• Registre des conteneurs Azure

Exemple pour Docker Hub:

 docker tag my-java-app: 1.0 your-dockerhub-username / my-java-app: 1.0
Docker pousse votre Dockerhub-username / My-Java-App: 1.0

Pour AWS ECR, authentifiez d'abord:

 AWS ECR Get-Login-Password | Docker Login --Username AWS --Password-Stdin <Count> .dkr.ecr. <Gare> .amazonaws.com

Puis étiquetez et poussez en conséquence.

? étape 6: Déployer sur la plate-forme cloud

Choisissez votre objectif de déploiement:

Option A: Kubernetes (EKS, GKE, AKS)

Utilisez un déploiement et un service YAML:

 Apversion: applications / v1
genre: déploiement
métadonnées:
  Nom: Java-App
SPEC:
  répliques: 2
  sélecteur:
    MatchLabels:
      App: Java-App
  modèle:
    métadonnées:
      étiquettes:
        App: Java-App
    SPEC:
      conteneurs:
      - Nom: Java-App
        Image: votre registre / my-java-app: 1.0
        PORTS:
        - Containerport: 8080
        ressources:
          Limites:
            Mémoire: "768mi"
            CPU: "500m"
---
Apversion: V1
genre: service
métadonnées:
  Nom: Java-App-Service
SPEC:
  Type: LoadBalancer
  sélecteur:
    App: Java-App
  PORTS:
    - Protocole: TCP
      Port: 80
      Targetport: 8080

Postuler avec:

 kubectl appliquer -f déploiement.yaml

Option B: Services gérés (par exemple, AWS ECS, Google Cloud Run)

Pour Cloud Run , une commande déploie directement à partir de l'image Docker:

 gcloud run deployer my-java-service \
  --image gcr.io/my-project/my-javaapp:1.0 \
  - Platform géré \
  - Region US-Central1 \
  -

De même, ECS utilise des définitions de taches faisant référence à votre image ECR.

? Automatiser avec CI / CD

Intégrer dans les actions GitHub, Gitlab CI ou Jenkins:

Exemple d'extrait de GitHub Action:

 Nom: construire et déployer
sur: [push]

Emplois:
  construire:
    Runs-on: Ubuntu-Latest
    mesures:
      - Utilisations: Actions / Checkout @ V3
      - Nom: configurer JDK 17
        Utilisations: Actions / Configuration-Java @ V3
        avec:
          Java-Version: '17'
          Distribution: 'Temurin'

      - Nom: construire avec maven
        Exécution: package MVN Clean -DSkiptests

      - Nom: Build Docker Image
        Run: docker build -t myApp: $ {{github.sha}}.

      - Nom: Push to docker Hub
        Courir: |
          echo $ {{secrets.docker_password}} | Docker Login -u $ {{secrets.docker_username}} --password-stdin
          docker tag myapp: $ {{github.sha}} $ {{secrets.docker_username}} / myapp: $ {{github.sha}}
          docker push $ {{secrets.docker_username}} / myapp: $ {{github.sha}}

Puis déclenchez le déploiement du cloud après la poussée.

? Conseils finaux

• Surveillez l'utilisation des ressources : réglez le tas JVM en fonction des limites de conteneurs.
• Activer la journalisation : stream des journaux sur les services cloud (cloudWatch, stackdriver).
• Vérification de la santé : utilisation /actuator/health (démarrage de printemps) dans les sondes de vivacité / préparation.
• Variables d'environnement : externalisez les configurations via application.properties ou Env Vars.

Fondamentalement, le docking d'une application Java n'est pas complexe - mais le faire en toute sécurité prend attention aux détails. Une fois conteneurisé, votre application devient une unité portable prête pour les plates-formes cloud modernes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!