Rubin's Blog

  • 首页
  • 关于作者
  • 隐私政策
享受恬静与美好~~~
分享生活的点点滴滴~~~
  1. 首页
  2. Docker
  3. 正文

Docker之创建镜像

2021年 12月 29日 553点热度 0人点赞 0条评论

基于已有的镜像创建

语法:

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 国际许可协议 进行许可
标签: Docker
最后更新:2022年 6月 9日

RubinChu

一个快乐的小逗比~~~

打赏 点赞
< 上一篇

文章评论

razz evil exclaim smile redface biggrin eek confused idea lol mad twisted rolleyes wink cool arrow neutral cry mrgreen drooling persevering
取消回复
文章目录
  • 基于已有的镜像创建
  • 基于Dockerfile来创建
    • Dockerfile的基本结构
    • Dockerfile文件说明
    • Dockerfile常见命令
    • 小例子
    • 部署微服项目
最新 热点 随机
最新 热点 随机
问题记录之Chrome设置屏蔽Https禁止调用Http行为 问题记录之Mac设置软链接 问题记录之JDK8连接MySQL数据库失败 面试系列之自我介绍 面试总结 算法思维
MyBatis之复杂映射开发 MySQL之Sharding-JDBC读写分离 RocketMQ之源码环境搭建 Nginx详解 MySQL之Sharding-JDBC简介 自定义简单的RPC框架

COPYRIGHT © 2021 rubinchu.com. ALL RIGHTS RESERVED.

Theme Kratos Made By Seaton Jiang

京ICP备19039146号-1