基于已有的镜像创建

语法：

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

常用参数：

-a：提交的镜像作者
-c：使用Dockerfile指令来创建镜像
-m：提交时的说明文字
-p：在commit时，将容器暂停

示例：

docker run -itd --name nginx -p 80:80 192.168.198.101:5000/rubin/nginx:v1

cd /data
echo "rubinchu" > /data/index.html

docker cp /data/index.html nginx:/usr/share/nginx/html/index.html

curl localhost

docker container commit -m "update index.html file" -a "rubin" nginx
 192.168.198.101:5000/rubin/nginx:v2

docker images

docker rm -f nginx

docker run -itd --name nginx -p 80:80 192.168.198.101:5000/rubin/nginx:v2

curl localhost

docker push 192.168.198.101:5000/rubin/nginx:v2

官网地址：

https://docs.docker.com/engine/reference/builder/

基于Dockerfile来创建

Dockerfile的基本结构

Dockerfile是一个包含用于组合映像的命令的文本文档。可以使用在命令行中调用任何命令。 Docker通过读取Dockerfile中的指令自动生成镜像。

docker build命令用于从Dockerfile构建映像。可以在docker build命令中使用-f标志指向文件系统中任何位置的Dockerfile。

Dockerfile由一行行命令语句组成，并且支持以#开头的注释行。

Dockerfile分为四部分：基础镜像信息、维护者信息、镜像操作指令和容器启动时执行指令。

语法：

docker build [OPTIONS] PATH | URL | -

常用参数：

build命令参数特别多。这里只给大家介绍几个常用的参数，如果小伙伴们想了解更多内容，请参考Docker官网手册。

--build-arg=[]：设置镜像创建时的变量
-f：指定要使用的Dockerfile路径
--rm：设置镜像成功后删除中间容器
--tag, -t：镜像的名字及标签，通常name:tag或者name格式。可以在一次构建中为一个镜像设置多个标签

Dockerfile文件说明

Docker以从上到下的顺序运行Dockerfile的指令。为了指定基本映像，第一条指令必须是FROM。一个声明以＃字符开头则被视为注释。可以在Docker文件中使用 RUN， CMD， FROM， EXPOSE， ENV等指令。

Dockerfile常见命令

命令	说明
FROM	指定基础镜像，必须为第一个命令
MAINTAINER	维护者(作者)信息
ENV	设置环境变量
RUN	构建镜像时执行的命令
CMD	构建容器后调用，也就是在容器启动时才进行调用
ENTRYPOINT	指定运行容器启动过程执行命令，覆盖CMD参数 ENTRYPOINT与CMD非常类似，不同的是通过docker run执行的命令不会覆盖ENTRYPOINT，而docker run命令中指定的任何参数，都会被当做参数再次传递给ENTRYPOINT。Dockerfile中只允许有一个ENTRYPOINT命令，多指定时会覆盖前面的设置，而只执行最后的ENTRYPOINT指令
ADD	将本地文件添加到容器中，tar类型文件会自动解压(网络压缩资源不会被解压)，可以访问网络资源，类似`wget`
COPY	功能类似ADD，但是不会自动解压文件，也不能访问网络资源
WORKDIR	工作目录，类似于`cd`命令
ARG	用于指定传递给构建运行时的变量
VOLUMN	用于指定持久化目录
EXPOSE	指定于外界交互的端口
USER	指定运行容器时的用户名或UID，后续的`RUN`也会使用指定用户。使用`USER`指定用户时，可以使用用户名、UID或GID，或是两者的组合。当服务不需要管理员权限时，可以通过该命令指定运行用户。并且可以在之前创建所需要的用户

小例子

Idea安装docker插件：

官网地址：
https://plugins.jetbrains.com/plugin/7724-docker/versions

修改MySQL官网镜像时区：

FROM mysql:5.7.31
# 作者信息
MAINTAINER mysql from date UTC by Asia/Shanghai "rubinchu@126.com"
ENV TZ Asia/Shanghai

制作镜像：

docker build --rm -t 192.168.198.101:5000/rubin/mysql:5.7.31
docker images

运行镜像：

docker run -itd --name mysql --restart always -p 3306:3306 -e
 MYSQL_ROOT_PASSWORD=admin 192.168.198.101:5000/rubin/mysql:5.7.31

docker logs -f mysql

docker exec -it mysql bash

date
观察时间是否与windows系统的时间一致

测试MySQL连接：

docker exec -it mysql bash
mysql -uroot -padmin

部署微服项目

创建数据库rubin-test。创建用户表如下：

创建student表
CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`student_name` varchar(20) COLLATE utf8_bin DEFAULT NULL,
`student_age` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin

创建一个SpringBoot项目：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.rubin</groupId>
    <artifactId>docker-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>docker-demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <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>
        </plugins>
    </build>

</project>

配置文件：

erver.port=8081
spring.application.name=docker-demo
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://182.92.116.114:3306/rubin-test?characterEncoding=utf-8&useSSL=false&useTimezone=true&serverTimezone=GMT%2B8
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=true

启动类：

package com.rubin.dockerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;

@SpringBootApplication
@EntityScan(basePackages = "com.rubin.dockerdemo.entity")
public class DockerDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DockerDemoApplication.class, args);
    }

}

控制器到DAO：

package com.rubin.dockerdemo.controller;

import com.rubin.dockerdemo.entity.Student;
import com.rubin.dockerdemo.service.IStudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class StudentController {

    @Autowired
    private IStudentService iStudentService;

    @GetMapping("/all")
    public List<Student> getAll() {
        return iStudentService.getAll();
    }

    @PostMapping("/save")
    public List<Student> save(@RequestBody Student student) {
        return iStudentService.save(student);
    }

    @DeleteMapping("/remove/{id}")
    public List<Student> remove(@PathVariable("id") Integer id) {
        return iStudentService.remove(id);
    }

}

package com.rubin.dockerdemo.service;

import com.rubin.dockerdemo.entity.Student;

import java.util.List;

public interface IStudentService {

    List<Student> getAll();

    List<Student> save(Student student);

    List<Student> remove(Integer id);

}

package com.rubin.dockerdemo.service.impl;

import com.rubin.dockerdemo.entity.Student;
import com.rubin.dockerdemo.repository.IStudentRepository;
import com.rubin.dockerdemo.service.IStudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentServiceImpl implements IStudentService {

    @Autowired
    private IStudentRepository iStudentRepository;


    @Override
    public List<Student> getAll() {
        return iStudentRepository.findAll();
    }

    @Override
    public List<Student> save(Student student) {
        iStudentRepository.save(student);
        return getAll();
    }

    @Override
    public List<Student> remove(Integer id) {
        iStudentRepository.deleteById(id);
        return getAll();
    }

}

package com.rubin.dockerdemo.repository;

import com.rubin.dockerdemo.entity.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface IStudentRepository extends JpaRepository<Student, Integer> {
}

实体类：

package com.rubin.dockerdemo.entity;

import lombok.Data;

import javax.persistence.*;

@Entity
@Table(name = "student")
@Data
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "student_name")
    private String studentName;

    @Column(name = "student_age")
    private Integer studentAge;

}

使用mvn clean package -Dmaven.test.skip=true来打包，打包之后上传到服务器。

准备MySQL镜像（这里使用一个主从环境）：

下载镜像：
docker pull bitnami/mysql:5.7.30

保存镜像：
docker save bitnami/mysql -o /data/image-tars/bitnami-mysql:5.7.30.tar

创建网络：
docker network create -d bridge rubin-bridge

启动主节点：
docker run -itd --name mysql-master \
 -p 3306:3306 \
 -e MYSQL_ROOT_PASSWORD=123456 \
 -e MYSQL_REPLICATION_MODE=master \
 -e MYSQL_REPLICATION_USER=rubin \
 -e MYSQL_REPLICATION_PASSWORD=rubin \
 -e MYSQL_DATABASE=rubin-test \
 --network rubin-bridge \
 -v /data/mysql/master/:/bitnami/mysql/data/ \
 -v /data/mysql/docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d \
bitnami/mysql:5.7.30

启动从节点：
docker run -itd --name mysql-slave \
 -p 3307:3306 \
 -e MYSQL_REPLICATION_MODE=slave \
 -e MYSQL_REPLICATION_USER=rubin \
 -e MYSQL_REPLICATION_PASSWORD=rubin \
 -e MYSQL_MASTER_HOST=182.92.116.114 \
 -e MYSQL_MASTER_ROOT_PASSWORD=123456 \
 -e MYSQL_MASTER_PORT_NUMBER=3306 \
 --network rubin-bridge \
 -v /data/mysql/slave/:/bitnami/mysql/data/ \
bitnami/mysql:5.7.30

制作我们自己的镜像，编写Dockerfile：

vim Dockerfile

FROM openjdk:8-alpine3.9
# 作者信息
MAINTAINER rubin Docker springboot "rubinchu@126.com"
# 修改源
RUN echo "http://mirrors.aliyun.com/alpine/latest-stable/main/" > /etc/apk/repositories && \
echo "http://mirrors.aliyun.com/alpine/latest-stable/community/" >> /etc/apk/repositories
# 安装需要的软件，解决时区问题
RUN apk --update add curl bash tzdata && \
rm -rf /var/cache/apk/*
#修改镜像为东八区时间
ENV TZ Asia/Shanghai
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
EXPOSE 8081
ENTRYPOINT ["java","-jar","/app.jar"]

制作镜像：

下载jdk镜像：
docker pull openjdk:8-alpine3.9
生成镜像：
docker build --rm -t rubin/dockerdemo:v1 --build-arg JAR_FILE=docker-demo-0.0.1-SNAPSHOT.jar .
启动：
docker run -itd --name docker-demo -p 8081:8081 --network rubin-bridge rubin/dockerdemo:v1

使用Postman测试我们的服务接口即可。

以上就是本文的全部内容。欢迎小伙伴们积极留言交流~~~

本作品采用知识共享署名 4.0 国际许可协议进行许可