在 Dockerfile 中安装 mysql 和 java jdk-11 并在容器中运行我的 spring boot jar 文件

Question

我将安装 MySQL 和 Jdk-11 并在容器上运行 jar 文件（spring boot 项目）。 如果有人有这方面的经验，请帮助。 谢谢

这是我的 sql 配置

    host='localhost',
                port=3306,
                user='root',
                passwd='password',

FROM ubuntu
RUN apt-get update
RUN apt-get -y install mysql-server
RUN apt-get -y install openjdk-11-jdk
COPY target/orderCodeBackEnd-0.0.1-SNAPSHOT.jar /usr/app/  
WORKDIR /usr/app
ENTRYPOINT ["java", "-jar", "orderCodeBackEnd-0.0.1-SNAPSHOT.jar"]

Answer 1

//Dockerfile
FROM openjdk:11
ADD target/*.jar app.jar
ENTRYPOINT ["java","-jar","app.jar"]

//Dockerfile just desame to other one
FROM openjdk:11
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

//docker-compose.yaml
services:

  yourapp:
    image: yourAppJarName:latest
    container_name: yourapp
    depends_on:
      - mysqldb
    restart: always
    build:
      context: ./
      dockerfile: Dockerfile
    
    ports: 
      - "9090:9090"
    environment:
      MYSQL_HOST: mysqldb
      MYSQL_USER: root
      MYSQL_PASSWORD: root
      MYSQL_PORT: 3306

  mysqldb:
    image: mysql:8.0.28
    restart: unless-stopped
    container_name: mysqldb
    ports: 
      - "3307:3306"
    
    cap_add:
      - SYS_NICE
    environment:
      MYSQL_DATABASE: dbname
      MYSQL_ROOT_PASSWORD: root 

//application.properties or yaml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://${MYSQL_HOST:localhost}:${MYSQL_PORT:3306}/dbname
    username: root
    password: root

//customize you jar name in pom.xml

</dependency>
    
    <dependency>
     ..........
     </dependency>
    <dependency>
     ..........
     </dependency>

</dependencies>
<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>   
            </plugin>
        </plugins>
        <finalName>yourAppJarName</finalName>
    </build>

  
</project>

Then click Project file then "Run as" then click maven "Install"

you must also open your mysql then connect to 3307 since 3307 is expose

Answer 2

1. 通过从 MySQL Docker 存储库中提取图像来创建 MySQL / MariaDB 容器。

sudo docker run --detach --env MARIADB_PASSWORD=secret --env MARIADB_ROOT_PASSWORD=secret -p 3306:3306 --add-host=YOUR_DESIRED_HOSTNAME:YOUR_LOCAL_MACHINE_IP mariadb:latest

• - 分离

将以分离模式运行服务器。

• --env MARIADB_PASSWORD=机密 --env MARIADB_ROOT_PASSWORD=机密

为您的数据库服务器密码设置环境变量。 您可以根据需要定义密码。 对我来说，我把它设置为secret

• -p 3306:3306

端口映射，容器内部的3306端口会映射到容器外部的3306端口。

• --add-host=YOUR_DESIRED_HOSTNAME:YOUR_LOCAL_MACHINE_IP

如果您想与 docker 主机建立远程连接，请不要忘记更改YOUR_DESIRED_HOSTNAME和YOUR_LOCAL_MACHINE_IP值。 通常，如果您在同一台开发机器上运行 docker，则主机名可以是localhost 。 在这种情况下，我们甚至不需要这个--add-host标志。

2. 现在，如果您在本地运行应用程序，则可以使用以下连接参数将应用程序与数据库连接起来。

    host: YOUR_LOCAL_MACHINE_IP
    port: 3306
    username: root
    password: secret

但是，如果您想从 docker 容器内访问 Spring Boot 应用程序的数据库，则可能必须使用其他工具 docker-compose。 原因是您的主机 IP 地址可能无法在您的 docker 容器中工作。

我认为，下面这个 git 存储库将有助于您了解如何编写您的第一个 docker-compose。 此存储库有一个 readme.md 文件，您可以从中获取帮助。

https://gitlab.com/mainul35/traver-auth

Answer 3

将不同的服务分隔在独立的容器中是一种很好的做法，从而创建了一个相关性较低的架构。

接下来想一想，在docker hub中，我们可以找到有用的、可以使用的图像。 我们可以从命令行提取所有图像并创建所有服务，但有更好的方法 - docker compose 。 所以第一个文件，你需要的是 docker-compose.yml：

version: '2'
services:
  mysql:
    image: mysql
    environment:
      - MYSQL_ROOT_PASSWORD=password
    ports:
      - 3306:3306
  app:
    build: .
    ports:
      - 8080:8080
    depends_on:
      - mysql

在这个文件中，我们描述了这 2 个服务：

• mysql:
  • 图像：图像来自 docker hub，它是官方的 docker mysql 图像
  • 环境变量：您可以在图像文档中找到所有可能的变量
  • 端口：我们可以指定要公开的端口
• 应用程序：
  • 构建：Dockerfile 的路径
  • depends_on：在创建这个服务之前，先创建mysql

应用程序的 Dockerfile：

FROM openjdk:11-jre

COPY target/orderCodeBackEnd-0.0.1-SNAPSHOT.jar /usr/app/

WORKDIR /usr/app

ENTRYPOINT ["java", "-jar", "orderCodeBackEnd-0.0.1-SNAPSHOT.jar"]

现在您可以从终端轻松启动这些服务

docker compose up -d

您必须在 docker-compose.yml 所在的目录中或指定 -f 参数

Answer 4

@ConRed 的答案并不完整。 我在我的应用程序中做了很多更改（在此处共享： https ://github.com/Aliuken/JobVacanciesApp_Java11）。

这些是我的最终文件：

码头工人-compose.yaml：

version: "3.9"

services:
  app-db-service:
    image: mysql:latest
    container_name: app-db-container
    ports:
      - "3307:3306"
    environment:
      - MYSQL_DATABASE=job-vacancies-app-db
      - MYSQL_ROOT_PASSWORD=admin
    networks:
      - internal-net
    restart: on-failure
    volumes:
      - app-db-data:/var/lib/mysql
      - ./src/main/resources/META-INF/db_dumps_folder:/docker-entrypoint-initdb.d
    cap_add:
      - SYS_NICE
    healthcheck:
      test: "mysql -uroot -padmin -e 'select 1'"
      interval: 1s
      retries: 120
      
  app-service:
    image: job-vacancies-app:latest
    container_name: app-container
    ports:
      - "9090:8080"
    environment:
      - MYSQL_HOST=app-db-container
      - MYSQL_PORT=3306
      - MYSQL_USER=root
      - MYSQL_PASSWORD=admin
    networks:
      - internal-net
      - external-net
    restart: on-failure
    volumes:
      - /AppData:/AppData
    depends_on:
      app-db-service:
        condition: service_healthy
    build:
      context: .
      dockerfile: Dockerfile

networks:
  external-net:
    external: true
  internal-net:
    driver: bridge

volumes:
  app-db-data:
    driver: local

在哪里：

• ./src/main/resources/META-INF/db_dumps_folder包含我的数据库转储文件： db-dump.sql 。
• /AppData是我的 PC（即 Linux）中的文件夹，其中包含应用程序中使用的图像和文档。
• healthcheck和service_healthy共同用于确定何时执行db-dump.sql文件，然后启动 Spring Boot 应用程序。
• internal-net用于将 Spring Boot 应用程序与数据库进行通信。
• external-net用于与用户通信 Spring Boot 应用程序。

Dockerfile：

FROM adoptopenjdk/openjdk11-openj9:alpine
USER root

RUN mkdir /opt/apps
RUN mkdir /opt/apps/jobVacanciesApp

ARG JAR_FILE=lib/*.jar
COPY ${JAR_FILE} /opt/apps/jobVacanciesApp/jobVacanciesApp.jar

RUN addgroup -S jobVacanciesAppGroup && adduser -S jobVacanciesAppUser -G jobVacanciesAppGroup
USER jobVacanciesAppUser:jobVacanciesAppGroup

CMD ["java", "-jar", "/opt/apps/jobVacanciesApp/jobVacanciesApp.jar"]

docker-compose-start.sh：

docker volume prune -f
docker network create "external-net"
docker-compose build
docker-compose up
docker-compose start

码头工人-撰写-stop.sh：

docker-compose stop
docker-compose down
docker volume prune -f
docker network rm "external-net"

应用程序.yaml：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://${MYSQL_HOST:localhost}:${MYSQL_PORT:3306}/job-vacancies-app-db?useSSL=false&serverTimezone=Europe/Madrid&allowPublicKeyRetrieval=true
    username: root
    password: admin

pom.xml：

...
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.aliuken.jobvacanciesapp.MainApplication</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-installed</id>
                        <phase>install</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>${project.groupId}</groupId>
                                    <artifactId>${project.artifactId}</artifactId>
                                    <version>${project.version}</version>
                                    <type>${project.packaging}</type>
                                    <outputDirectory>lib</outputDirectory>
                                    <destFileName>job-vacancies-app.jar</destFileName>
                                </artifactItem>
                            </artifactItems>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        <finalName>job-vacancies-app</finalName>
    </build>
...

要运行应用程序：

• 在终端中执行： ./docker-compose-start.sh
• 在网络浏览器中打开： http://localhost:9090

要停止应用程序：

• 按下之前打开的终端： Ctrl + C
• 在终端执行： ./docker-compose-stop.sh