如何在Jenkinsfile中构建三个不同的Docker镜像？

Hey there! Let's figure out how to set up your Jenkinsfile to build those three Docker images (Wildfly, Postgres, Virtuoso) — each with their own independent Dockerfile. First, I noticed your current command sh docker build docker docker-compose.yml looks a bit off (probably a typo, since docker build doesn’t accept a docker-compose.yml directly). Let’s fix that and structure your Jenkinsfile properly with two common approaches.

Option 1: Build Each Image Individually (Great for Fine-Grained Control) #

If each Dockerfile lives in its own dedicated directory (e.g., ./wildfly/Dockerfile, ./postgres/Dockerfile, ./virtuoso/Dockerfile), you can create separate stages in your Jenkinsfile to build each image. This gives you full control over each build process, like adding specific tags or post-build steps per image.

Here’s a sample Jenkinsfile:

pipeline {
    agent any  // Use a Jenkins agent with Docker installed

    stages {
        stage('Build Wildfly Image') {
            steps {
                script {
                    // Build the Wildfly image and tag it (adjust the tag/directory as needed)
                    sh 'docker build -t my-wildfly:latest ./wildfly'
                }
            }
        }

        stage('Build Postgres Image') {
            steps {
                script {
                    sh 'docker build -t my-postgres:latest ./postgres'
                }
            }
        }

        stage('Build Virtuoso Image') {
            steps {
                script {
                    sh 'docker build -t my-virtuoso:latest ./virtuoso'
                }
            }
        }
    }

    post {
        success {
            echo '🎉 All three Docker images built successfully!'
        }
        failure {
            echo '❌ Oops, one or more image builds failed. Check the logs for details.'
        }
    }
}

Notes for This Option: #

• Replace my-wildfly:latest (and similar tags) with your preferred image names/tags.
• If your Dockerfiles aren’t in subdirectories, adjust the path in docker build to point directly to the directory containing each Dockerfile.

Option 2: Use Docker Compose (Simpler for Multi-Service Setups) #

If you already have a docker-compose.yml that defines all three services (each pointing to their respective Dockerfile directories), you can use docker-compose build to build all images in one go. This is cleaner if you plan to run these services together later.

First, make sure your docker-compose.yml looks something like this:

version: '3.8'
services:
  wildfly:
    build: ./wildfly  # Path to Wildfly's Dockerfile directory
    image: my-wildfly:latest
  postgres:
    build: ./postgres
    image: my-postgres:latest
  virtuoso:
    build: ./virtuoso
    image: my-virtuoso:latest

Then your Jenkinsfile can be simplified to:

pipeline {
    agent any  // Ensure the agent has Docker Compose installed

    stages {
        stage('Build All Images via Docker Compose') {
            steps {
                script {
                    // Build all services defined in docker-compose.yml
                    sh 'docker-compose build'
                }
            }
        }
    }

    post {
        success {
            echo '🎉 All images built successfully using Docker Compose!'
        }
        failure {
            echo '❌ Docker Compose build failed. Verify your docker-compose.yml configuration.'
        }
    }
}

Critical Prerequisites for Both Options: #

• The Jenkins agent (or server) must have Docker installed (and Docker Compose if using Option 2).
• The jenkins user needs permissions to run Docker commands. You can grant this by adding the user to the docker group: sudo usermod -aG docker jenkins (then restart Jenkins).

内容的提问来源于stack exchange，提问作者Shanmukh Borole