Docker部署MySQL8主从模式

Docker部署MySQL8主从模式

文章目录


Mysql 8.1.0
Docker 24.0.5

关于主从模式,Mysql8.0一些版本开始,有许多变化,这里使用8.1.0

一、运行容器

新建两个MySQL文件夹,分别新建data文件夹和conf/my.cnf文件。
根据需要理解并更改以下脚本。

language-bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/bin/bash

containerName="MyWeb02-MySQL"
MySQLData="/root/MyWeb02/MySQL/data"
MySQLConf="/root/MyWeb02/MySQL/conf/my.cnf"

containerSlaveName="MyWeb02-MySQL-Slave"
MySQLSlaveData="/root/MyWeb02/MySQL-Slave/data"
MySQLSlaveConf="/root/MyWeb02/MySQL-Slave/conf/my.cnf"

docker run -d --name "$containerName" \
-p 3307:3306 \
-v "$MySQLData":/var/lib/mysql \
-v "$MySQLConf":/etc/mysql/my.cnf \
-e MYSQL_ROOT_PASSWORD=20028888 \
mysql:8

docker run -d --name "$containerSlaveName" \
-p 3308:3306 \
-v "$MySQLSlaveData":/var/lib/mysql \
-v "$MySQLSlaveConf":/etc/mysql/my.cnf \
-e MYSQL_ROOT_PASSWORD=20028888 \
mysql:8

主节点的my.cnf容器如下

language-bash
1
2
3
[mysqld]
server-id=1
log_bin=mysql-bin

从节点的my.cnf容器如下

language-bash
1
2
[mysqld]
server-id=2

运行脚本。

二、配置主从

到主节点命令行,运行以下命令

language-sql
1
2
CREATE USER 'replica'@'%' IDENTIFIED WITH mysql_native_password BY 'replica';
GRANT REPLICATION SLAVE ON *.* TO 'replica'@'%';

到从节点命令行,运行以下命令

language-sql
1
2
3
4
5
6
7
CHANGE REPLICATION SOURCE TO 
SOURCE_HOST='172.17.0.6',
SOURCE_PORT=3306,
SOURCE_USER='replica',
SOURCE_PASSWORD='replica';
START REPLICA; //开启备份
SHOW REPLICA STATUS\G //查看主从情况

其中SOURCE_HOST为主节点容器的ip
查看主从情况时,主要注意下面两个字段是否为Yes。不是的话,就有问题,读docker logs然后去解决它。

language-bash
1
2
Slave_IO_Running: Yes
Slave_SQL_Running: Yes

Navicat等第三方软件可能不支持\G,结果以行显示。

三、测试效果

在主节点新建一个数据库

language-bash
1
create database `test`;

随后可以在从节点也看到效果。

云服务器Docker部署SpringBoot+Vue前后端(Ubuntu)

云服务器Docker部署SpringBoot+Vue前后端(Ubuntu)

本文创作环境
华为云Ubuntu22.04
需要对以下知识具备一定了解和经验

  • Linux和Docker使用基础
  • Vue基本使用
  • SpringBoot基本使用

一、起手式-环境配置

1.远程服务器免密

在远程服务器执行ssh-keygen -t rsa,得到如下三个文件

language-bash
1
2
3
4
5
root@hecs-295176:~# ls -lh .ssh/
total 12K
-rw------- 1 root root 570 Oct 21 15:14 authorized_keys
-rw------- 1 root root 2.6K Oct 21 15:09 id_rsa
-rw-r--r-- 1 root root 570 Oct 21 15:09 id_rsa.pub

id_rsa.pub内容复制到authorized_keys,然后将id_rsa下载到本地。
在VsCode使用Remote-SSH配置远程免密登录,例如

language-bash
1
2
3
4
5
Host huaweiYun
HostName xxx.xxx.xxx.xxx
User root
Port 22
IdentityFile "C:\Users\mumu\.ssh\id_rsa"

2.安装Docker

执行以下命令安装Docker并检查docker命令是否可以使用

language-bash
1
2
3
4
5
apt update
apt upgrade
apt install docker.io
docker ps -a
docker images -a

二、Vue前端部署

1.参考文件夹结构

文件先不用创建,按照下面结构先把文件夹创建出来
然后将你的Vue打包后的dist文件夹替换下面的dist文件夹(如果没有Vue的打包文件夹本人建议先在index.html随便写点东西等会看能不能访问)

language-html
1
2
3
4
5
6
7
8
9
10
11
12
13
/root
├── conf
│ └── nginx
│ ├── default.conf
│ └── nginx.conf
└── Vue
├── MyTest01
│ ├── dist
│ │ └── index.html
│ └── logs
│ ├── access.log
│ └── error.log
└── nginxDocker.sh

2.nginx

拉取nginx镜像并创建nginx容器

language-bash
1
2
docker pull nginx
docker run -itd nginx

把里面的两个配置文件复制到主机

language-bash
1
2
docker cp containerName:/etc/nginx/nginx.conf ~/conf/nginx/nginx.conf
docker cp containerName:/etc/nginx/conf.d/default.conf ~/conf/nginx/default.conf

编辑default.conf 文件,修改以下内容:

  • listen 80; 改为 listen 8080;,表示 nginx 容器监听 8080 端口。
  • root /usr/share/nginx/html; 改为 root /usr/share/nginx/dist;,表示 nginx容器的根目录为 /usr/share/nginx/dist
  • index index.html index.htm; 改为 index index.html;,表示 nginx 容器的默认首页为 index.html。

参考第一小步文件夹结构,把以下内容写入nginxDocker.sh

language-bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/bin/bash

containerName="Test01"
nginxConf="/root/conf/nginx/nginx.conf"
defaultConf="/root/conf/nginx/default.conf"
logsPath="/root/Vue/MyTest01/logs"
vuePath="/root/Vue/MyTest01/dist"

docker run -d --name "$containerName" \
-v "$nginxConf":/etc/nginx/nginx.conf \
-v "$defaultConf":/etc/nginx/conf.d/default.conf \
-v "$logsPath":/var/log/nginx \
-v "$vuePath":/usr/share/nginx/dist \
-p 8080:8080 \
nginx

命令行运行这个sh脚本并查看当前容器列表确认容器已经在运行中

language-bash
1
2
bash Vue/nginxDocker.sh
docker ps -a

3.开放8080端口

如果你使用的VsCode远程连接的服务器,那么可以先通过端口转发,在本地访问前端服务。
如果想要别人通过公网访问,需要去购买云服务器的平台,修改服务器的安全组配置,添加入站规则,开放8080端口。
之后使用IP+8080即可访问这个docker容器里的前端服务。

4.复盘

首先是更新便捷性,使用-v挂载文件到容器,我们可以直接修改主机的dist文件夹内容而不必对容器做任何操作,前端服务就可以自动update,其它-v挂载的文件都可以在主机直接修改而不必连入容器中修改,同时重启容器即可一定保证所有服务重启。
其次是多开便捷性,以上流程就是一个包裹了前端服务的docker占一个端口,如果有多个Vue前端,使用不同端口即可。
总而言之,都是选择Docker容器化的优势所在。

三、SpringBoot后端部署

1.参考文件夹结构

将maven打包好的jar包如下图放入对应位置

language-bash
1
2
3
4
SpringBoot
├── javaDocker.sh
└── MyTest01
└── demo-0.0.1-SNAPSHOT.jar

2.openjdk17

以java17举例,拉取对应docker镜像(java8对应的镜像是java:8 )

language-bash
1
docker pull openjdk:17

如下编写javaDocker.sh脚本

language-bash
1
2
3
4
5
6
7
8
9
#!/bin/bash

containerName="JavaTest01"
SpringBootPath="/root/SpringBoot/MyTest01/demo-0.0.1-SNAPSHOT.jar"

docker run -d --name "$containerName" \
-p 8081:8081 \
-v "$SpringBootPath":/app/your-app.jar \
openjdk:17 java -jar /app/your-app.jar

命令行运行这个sh脚本并查看当前容器列表确认容器已经在运行中

language-bash
1
2
bash SpringBoot/javaDocker.sh
docker ps -a

3.开放8081端口

需要去购买云服务器的平台,修改服务器的安全组配置,添加入站规则,开放8081端口。
打开浏览器,输入IP:8081然后跟上一些你在程序中写的api路径,验证是否有返回。

四、Vue->Axios->SpringBoot前后端通信简单实现

vue这里使用ts + setup +组合式 语法举例,前端代码如下
意思是向IP为xxx.xxx.xxx.xxx的云服务器的8081端口服务发送路径为/Home/Kmo的请求

language-html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<template>
<div>
Your Remote JavaDocker State : {
{ line }}
</div>
</template>

<script setup lang="ts">
import {
ref } from "vue";
import axios from "axios";
const line = ref("fail");
axios.get("http://xxx.xxx.xxx.xxx:8081/Home/Kmo").then(rp=>{

line.value = rp.data
})
</script>


<style scoped>
</style>

SpringBoot后端写一个简单Controller类,代码如下

language-java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.kmo.demo.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@CrossOrigin(originPatterns = "*", allowCredentials = "true")
@RestController
@RequestMapping("Home")
public class TestController {


@GetMapping("/Kmo")
public String test(){

return "Success!";
}

}

分别打包放到云服务指定文件夹,然后restart重启两个docker容器即可,在本地浏览器访问IP:8080看看效果吧。

(完)

云服务器部署可视化Docker私有仓库(Ubuntu)

云服务器部署可视化Docker私有仓库(Ubuntu)

这里测试的机器为ubuntu22.04

一、环境安装

docker安装就不赘述了
先升级,再从官方仓库安装docker compose

language-bash
1
2
3
apt update
apt upgrade
apt install docker-compose

二、部署私有仓库UI

Docker提供了一个叫registry的镜像,给大家搭建私有仓库,但是没有可视化界面。
https://hub.docker.com/r/joxit/docker-registry-ui
这个镜像在registry基础之上,开发了网页可视化。

1. 创建一个文件夹Docker_Registry

2. 进入其中继续创建registry-data文件夹和docker-compose.yaml文件

3. yaml文件

language-yaml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
version: '3.8'

services:
registry-ui:
image: joxit/docker-registry-ui:main
restart: always
ports:
- 8090:80 #这里8090改成可视化网页服务端口
environment:
- SINGLE_REGISTRY=true
- REGISTRY_TITLE=Xiamu Docker Registry UI #这里可以修改标题
- DELETE_IMAGES=true
- SHOW_CONTENT_DIGEST=true
- NGINX_PROXY_PASS_URL=http://registry-server:5000
- SHOW_CATALOG_NB_TAGS=true
- CATALOG_MIN_BRANCHES=1
- CATALOG_MAX_BRANCHES=1
- TAGLIST_PAGE_SIZE=100
- REGISTRY_SECURED=false
- CATALOG_ELEMENTS_LIMIT=1000
container_name: registry-ui
depends_on:
- registry-server

registry-server:
image: registry:2.8.2
restart: always
environment:
REGISTRY_HTTP_HEADERS_Access-Control-Origin: '[http://your_server_ip]' # 这里改成你的云服务ip,启用CORS
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Methods: '[HEAD,GET,OPTIONS,DELETE]'
REGISTRY_HTTP_HEADERS_Access-Control-Credentials: '[true]'
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Headers: '[Authorization,Accept,Cache-Control]'
REGISTRY_HTTP_HEADERS_Access-Control-Expose-Headers: '[Docker-Content-Digest]'
REGISTRY_STORAGE_DELETE_ENABLED: 'true'
volumes:
- ./registry-data:/var/lib/registry
container_name: registry-server

4. 部署

进入Docker_Registry目录,执行

language-bash
1
docker-compose -f ./docker-compose.yaml up

三、访问

通过http://your_server_ip:8090 访问UI

四、上传和拉取镜像

打开vi /etc/docker/daemon.json添加以下内容:

language-txt
1
"insecure-registries":["http://your_server_ip:8090"]

这样docker才会信任你的私有仓库。

假设你的服务器ip为192.168.750.101,port为8090
推送镜像到私有镜像服务必须先tag,步骤如下:

  1. 重新tag本地镜像,名称前缀为私有仓库的地址: 192.168.150.101:8090/
language-dart
1
docker tag nginx:latest 192.168.150.101:8090/nginx:1.0
  1. 推送镜像
language-dart
1
docker push 192.168.150.101:8090/nginx:1.0
  1. 拉取镜像
language-dart
1
docker pull 192.168.150.101:8090/nginx:1.0
Docker Compose怎么保证其他服务在Nacos完全启动后再启动

Docker Compose怎么保证其他服务在Nacos完全启动后再启动

首先,docker compose有一个关键字depends_on是可以一定程度解决services之间的依赖问题,但是depends_on仅仅只是指定了services的启动顺序,并不能保证,前置service完全启动后,后置service才启动。

此时,需要另一个关键字叫healthcheck

样例

nacos版本为v2.3.0

language-yaml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
  mysql_nacos:
container_name: mysql_nacos
build:
context: .
dockerfile: ./image/mysql/5.7/Dockerfile
image: example/mysql:5.7
env_file:
- ../env/mysql.env
volumes:
- ./mysql:/var/lib/mysql
# ports:
# - "3307:3306"
healthcheck:
test: [ "CMD", "mysqladmin" ,"ping", "-h", "localhost", "-u", "root", "-p${MYSQL_ROOT_PASSWORD}" ]
interval: 10s
timeout: 10s
retries: 10

nacos1:
hostname: nacos1
container_name: nacos1
image: nacos/nacos-server:${
NACOS_VERSION}
volumes:
- ./cluster-logs/nacos1:/home/nacos/logs
# ports:
# - "7848:7848"
# - "8845:8848"
# - "9868:9848"
# - "9850:9849"
env_file:
- ../env/nacos-hostname.env
# restart: always
healthcheck:
test: [ "CMD", "curl", "-f", "http://localhost:8848/nacos/v1/console/health/readiness" ]
interval: 10s
timeout: 10s
retries: 10
depends_on:
mysql_nacos:
condition: service_healthy

nginx_nacos:
hostname: nginx_nacos
image: nginx:stable
container_name: nginx_nacos
volumes:
- ../nginx_nacos/nginx.conf:/etc/nginx/nginx.conf
- ../nginx_nacos/conf.d/default.conf:/etc/nginx/conf.d/default.conf
- ../nginx_nacos/logs:/var/log/nginx
- ../nginx_nacos/html:/usr/share/nginx/html
ports:
- "80:80"
depends_on:
nacos1:
condition: service_healthy

这是一个双层依赖,nginx_nacos依赖于nacos1,同时nacos1依赖于mysql_nacos

mysql_nacos基于 healthcheck:test: [ "CMD", "mysqladmin" ,"ping", "-h", "localhost", "-u", "root", "-p${MYSQL_ROOT_PASSWORD}" ]来确认自己的健康状态,只有当test内容执行成功并返回状态码0,才会认为此service已完全执行成功。

同理nacos服务是基于healthcheck:test: [ "CMD", "curl", "-f", "http://localhost:8848/nacos/v1/console/health/readiness" ]来判断健康状态的。

云服务器Docker部署SpringBoot+Redis(Ubuntu)

云服务器Docker部署SpringBoot+Redis(Ubuntu)

参考文件夹结构

language-bash
1
2
3
4
5
6
7
MyTest01
├── javaDocker.sh
├── redisDocker.sh
├── Redis
│ └── data
├── SpringBoot
└── MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar

一、起手式:配置环境

1.镜像

拉取以下两个镜像

language-bash
1
2
docker pull openjdk:17
docker pull redis

二、启动Redis容器

redisDocker.sh脚本写入以下内容,然后bash运行
脚本意思是将redis数据映射到主机

language-bash
1
2
3
4
5
6
7
8
9
#!/bin/bash

containerName="RedisTest01"
RedisData="/root/MyTest01/Redis/data"

docker run -d --name "$containerName" \
-v "$RedisData":/data \
-p 6379:6379 \
redis

三、配置SpringBoot容器并简单测试

添加如下配置到application.yml

language-yaml
1
2
3
4
5
6
spring:
data:
redis:
host: redisdb
port: 6379
password:

写一个简单的测试如下

language-java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.example.myweb01springboot.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.sql.SQLException;

@RestController
@RequestMapping("/Home")
@CrossOrigin(origins = "*", allowedHeaders = "*")
public class TestController {

@Autowired
private RedisTemplate<String, String> redisTemplate;

@GetMapping("/Kmo")
public String test() throws SQLException {

// 设置一个键值对
redisTemplate.opsForValue().set("name", "张三");

// 获取一个键值对
String name = redisTemplate.opsForValue().get("name");

System.out.println(name);

return "Success!"+name;
}
}

然后maven打包成jar,参考文件夹结构,将jar放入指定位置。
将以下内容写入javaDocker.sh脚本并bash运行
脚本意思是,向名为MySQLTest01的容器建立网络链接(单向的),它的名字(IP,主机名)为db,于是此容器可以通过db:3306访问MySQLTest01容器的mysql服务。

language-bash
1
2
3
4
5
6
7
8
9
10
11
#!/bin/bash

containerName="JavaTest01"
SpringBootPath="/root/MyTest01/SpringBoot/MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar"

docker run -d --name "$containerName" \
-p 8081:8081 \
--link RedisTest01:redisdb \
-v "$SpringBootPath":/app/your-app.jar \
openjdk:17 java -jar /app/your-app.jar

开放云服务器安全组入站规则8081端口,浏览器访问云服务器IP:8081/Home/Kmo验证。

(完)

云服务器Docker部署SpringBoot+MySQL(Ubuntu)

云服务器Docker部署SpringBoot+MySQL(Ubuntu)

参考文件夹结构

language-bash
1
2
3
4
5
6
7
MyTest01
├── javaDocker.sh
├── mysqlDocker.sh
├── MySQL
│ └── data
├── SpringBoot
└── MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar

一、起手式:配置环境

1.镜像

拉取以下两个镜像

language-bash
1
2
docker pull openjdk:17
docker pull mysql:8

二、启动Mysql容器

mysqlDocker.sh脚本写入以下内容,然后bash运行
脚本意思是将mysql数据映射到主机并设置密码为xxxx,

language-bash
1
2
3
4
5
6
7
8
9
10
#!/bin/bash

containerName="MySQLTest01"
MySQLData="/root/MyTest01/MySQL/data"

docker run -d --name "$containerName" \
-p 3306:3306 \
-v "$MySQLData":/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=xxxx \
mysql:8

在云服务器安全组开放入站规则3306端口
此时可以用你喜欢的数据库连接软件来连接这个mysql容器,并创建test01数据库和一张student表,结构随意,随便插入几条数据。

三、配置SpringBoot容器并简单测试

添加如下配置到application.yml
补充你的云服务器IP和刚才设置的密码

language-yaml
1
2
3
4
5
6
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://xxx.xxx.xxx.xxx:3306/test01?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: xxxx

写一个简单的测试如下

language-java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.example.myweb01springboot.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.sql.SQLException;

@RestController
@RequestMapping("/Home")
@CrossOrigin(origins = "*", allowedHeaders = "*")
public class TestController {

@Autowired
DataSource dataSource;

@Autowired
JdbcTemplate jdbcTemplate;
@GetMapping("/Kmo")
public String test() throws SQLException {

System.out.println("默认数据源为:" + dataSource.getClass());
System.out.println("数据库连接实例:" + dataSource.getConnection());
//访问数据库user表,查询user表的数据量
Integer i = jdbcTemplate.queryForObject("SELECT count(*) from `student`", Integer.class);
System.out.println("user 表中共有" + i + "条数据。");

return "Success!"+i;
}
}

然后本地运行打开浏览器访问localhost:8081/Home/Kmo验证是否从远程数据库取得连接。
然后在application.yml中将url的服务器IP改成db

language-yaml
1
2
3
4
5
6
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://db:3306/test01?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: xxxx

然后maven打包成jar,参考文件夹结构,将jar放入指定位置。
将以下内容写入javaDocker.sh脚本并bash运行
脚本意思是,向名为MySQLTest01的容器建立网络链接(单向的),它的名字(IP,主机名)为db,于是此容器可以通过db:3306访问MySQLTest01容器的mysql服务。

language-bash
1
2
3
4
5
6
7
8
9
10
11
#!/bin/bash

containerName="JavaTest01"
SpringBootPath="/root/MyTest01/SpringBoot/MyWeb01-SpringBoot-0.0.1-SNAPSHOT.jar"

docker run -d --name "$containerName" \
-p 8081:8081 \
--link MySQLTest01:db \
-v "$SpringBootPath":/app/your-app.jar \
openjdk:17 java -jar /app/your-app.jar

开放云服务器安全组入站规则8081端口,浏览器访问云服务器IP:8081/Home/Kmo验证。

结束后记得关闭云服务器的3306入站规则

(完)

Linux+Docker部署基于Ambari的Hadoop集群

Linux+Docker部署基于Ambari的Hadoop集群

建议文档和视频一起食用。

文档链接

文档https://1138882663s-organization.gitbook.io/between-code-and-words/bigdata/ambari/da-jian-xu-ni-ji-ji-qun-yi-ji-an-zhuang-ambari

视频链接视频https://b23.tv/YdYulVJ

docker因为容器化技术和虚拟化技术的区别,部署hadoop会存在很多bug。建议使用虚拟机而不是容器。

https://www.bilibili.com/video/BV1Az4y1v7Zw/https://www.bilibili.com/video/BV1Az4y1v7Zw/

优雅地给Docker容器添加新端口

优雅地给Docker容器添加新端口

一共分为三步,停止容器和docker服务,修改配置文件,重启服务和容器。

这里只讲如何修改配置文件。

如果你是Linux环境

容器配置文件hostconfig.json 通常位于 /var/lib/docker/containers/[hash_of_the_container]/hostconfig.json 或者 /var/snap/docker/common/var-lib-docker/containers/[hash_of_the_container]/hostconfig.json

找到PortBindings字段,以下是一个端口的格式例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
"PortBindings": {
"8080/tcp": [
{
"HostIp": "",
"HostPort": "8080"
}
],
"8088/tcp": [
{
"HostIp": "",
"HostPort": "8088"
}
]
},

如果不起作用,建议同时修改下面提到的config.v2.json

如果你是windws+wsl2环境

那么你需要修改两个文件,hostconfig.jsonconfig.v2.json,它们都位于/mnt/wsl/docker-desktop-data/data/docker/<containerID>下。

hostconfig.json文件修改和linux的一样。

config.v2.json需要修改以下两个字段

1
2
3
"ExposedPorts":{"8080/tcp":{},"8088/tcp":{}}

"Ports":{"8080/tcp":[{"HostIp":"0.0.0.0","HostPort":"8080"}],"8088/tcp":[{"HostIp":"0.0.0.0","HostPort":"8088"}]}

参考资料

How do I assign a port mapping to an existing Docker container? - Stack Overflowhttps://stackoverflow.com/questions/19335444/how-do-i-assign-a-port-mapping-to-an-existing-docker-containerAdding new exposed ports to existing docker container (Windows/WSL 2) | by LifeOnKeyboardBlog | Mediumhttps://medium.com/@lifeonkeyboardblog/adding-new-exposed-ports-to-existing-docker-container-windows-wsl-2-3cfe58d551e

Docker容器中删除文件后,大小不减反增怎么办?

Docker容器中删除文件后,大小不减反增怎么办?

Docker的镜像是由多层存储结构组成的,每一层都是只读的,所以您无法删除之前层的操作。

但是可以通过以下步骤达到一样的效果。

假设你从原始镜像a中创建了容器b。

现在你在容器b中删除了一些东西。

您可以使用docker export命令将容器的文件系统导出为一个tar文件:

1
docker export -o my.tar containerID

然后,使用docker import命令从这个tar文件导入为一个新的镜像:

1
docker import my.tar new-image

此时这个new-image镜像就摆脱了旧镜像的历史层,大小也会相应大大减少。

但是你可能会失去一些东西:环境变量、端口映射、镜像的历史记录和层级结构、镜像的标签和版本号、镜像的创建时间和作者、容器的启动命令和参数等等。