Docker 之安装开发环境软件

原创已于 2025-05-21 22:51:08 修改 · 706 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#docker

于 2020-05-10 14:53:44 首次发布

Docker 专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍如何使用Docker快速安装并配置Mysql、Redis、nginx、Elasticsearch、Kibana等常用服务，同时演示了Java应用的Docker化过程及镜像推送到阿里云的步骤。

文章目录

查看容器的自启动设置
Docker镜像命令
Docker compose 安装 Mysql 、Redis、Nacos
Docker 安装 Mysql5.7
Docker搭建Mysql8.0.20服务
Docker搭建Mysql主从复制
Docker 安装 Redis
Docker compose 安装 Redis
Docker 安装 nginx
Docker 安装 Elasticsearch、Kibana
Docker 运行 Java 应用
Docker 推送镜像到阿里云
Docker 自定义镜像
Docker 安装 Kafka
Docker 安装 nacos

查看容器的自启动设置

确认容器的自启动状态。
Name字段的值决定了容器的自启动策略。
no：容器不会自动重启。
always：容器总是重启。
root@ubuntu20-11:~# docker inspect nginx | grep -C2 'RestartPolicy'
                ]
            },
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
root@ubuntu20-11:~# docker update nginx --restart=always
nginx
root@ubuntu20-11:~# docker inspect nginx | grep -C2 'RestartPolicy'
                ]
            },
            "RestartPolicy": {
                "Name": "always",
                "MaximumRetryCount": 0
root@ubuntu20-11:~#

Docker镜像命令

# 将指定的 Docker 镜像保存为一个 tar 归档文件
docker save -o kafka.tar kafka
# 加载镜像
docker load -i kafka.tar

Docker compose 安装 Mysql 、Redis、Nacos

# Mysql、Redis配置准备：
mkdir -p /home/docker/mysql/log
mkdir -p /home/docker/mysql/data
mkdir -p /home/docker/mysql/conf
mkdir -p /home/docker/redis/data
mkdir -p /home/docker/redis/conf

touch /home/docker/mysql/conf/my.cnf
touch /home/docker/redis/conf/redis.conf

# my.cnf:
[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
[mysqld]
max_connections=1024
init_connect="SET collation_connection = utf8mb4_unicode_ci"
init_connect="SET NAMES utf8mb4"
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
lower_case_table_names=1
default-time-zone=Asia/Shanghai

# redis.conf:
protected-mode no
appendonly yes
requirepass 123456

# Nacos配置准备：
mkdir -p /home/docker/nacos/conf
mkdir -p /home/docker/nacos/logs

# 创建临时Nacos容器(会删除)，将容器内部conf和logs下的文件拷贝到宿主机，这一步一定要做
docker run -d --name nacos -p 8848:8848 -e MODE=standalone nacos/nacos-server:v2.4.1
docker logs -f nacos
docker cp nacos:/home/nacos/logs /home/docker/nacos
docker cp nacos:/home/nacos/conf /home/docker/nacos
# 删除Nacos容器
docker rm -f nacos

# 编写docker-compose编排文件：
touch /home/docker/docker-compose.yml
docker compose -f /home/docker/docker-compose.yml up -d

# docker-compose.yml:
version: '3'
services:
  mysql:
    image: mysql:5.7
    container_name: mysql
    ports:
      - 3306:3306
    environment:
      - MYSQL_ROOT_PASSWORD=123456
    volumes:
      - /home/docker/mysql/log:/var/log/mysql
      - /home/docker/mysql/data:/var/lib/mysql
      - /home/docker/mysql/conf:/etc/mysql/conf.d
      - /etc/localtime:/etc/localtime:ro
    restart: always
    privileged: true
  redis:
    image: redis:7.2.3
    container_name: redis
    ports:
      - 6379:6379
    volumes:
      - /home/docker/redis/conf/redis.conf:/etc/redis/redis.conf
      - /home/docker/redis/data:/data
    restart: always
    privileged: true
    command: ["redis-server","/etc/redis/redis.conf"]
  nacos:
    image: nacos/nacos-server:v2.4.1
    container_name: nacos
    ports:
      - 8848:8848
      - 9848:9848
      - 9849:9849
    environment:
      - MODE=standalone
      - TZ=Asia/Shanghai
      - JVM_XMX=128m
      - JVM_XMS=128m
      - NACOS_AUTH_ENABLE=true
      - NACOS_AUTH_TOKEN=SecretKey01234567890123456789012345345678999987654901234567890123456789
      - NACOS_AUTH_IDENTITY_KEY=nacos
      - NACOS_AUTH_IDENTITY_VALUE=nacos
    volumes:
      - /home/docker/nacos/conf:/home/nacos/conf
      - /home/docker/nacos/logs:/home/nacos/logs
    restart: always

Docker 安装 Mysql5.7

拉取官方Mysql镜像

# 拉取 mysql5.7
docker pull mysql:5.7   
# 拉取最新版mysql镜像
docker pull mysql       
docker cp /home/mysql.conf.d/my.cnf  mysql3381:/etc/mysql/mysql.conf.d/my.cnf
# 快速创建容器
docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
docker rm -f mysql

创建一个Mysql容器

mkdir -p /home/docker/mysql/log
mkdir -p /home/docker/mysql/data
mkdir -p /home/docker/mysql/conf

docker run -d --name mysql \
-p 3306:3306 \
-v /home/docker/mysql/log:/var/log/mysql \
-v /home/docker/mysql/data:/var/lib/mysql \
-v /home/docker/mysql/conf:/etc/mysql/conf.d \
-e MYSQL_ROOT_PASSWORD=123456 \
--privileged=true \
--restart=always \
mysql:5.7

touch /home/docker/mysql/conf/my.cnf
[mysqld]
lower_case_table_names=1
default-time-zone = Asia/Shanghai

docker restart mysql

-v：挂载文件，启动的时候把容器中的文件映射到虚拟机文件当中
–name：容器名，此处命名为mysql
-e：配置信息，此处配置mysql的root用户的登陆密码
-p：端口映射，(3380)冒号前面是主机端口，(3306)冒号后面容器内部端口
-d：源镜像名，此处为 mysql:5.7

修改配置文件

vi /home/docker/mysql/conf/my.cnf

[client]
default-character-set=utf8mb4
[mysql]
default-character-set=utf8mb4
[mysqld]
max_connections=1024
init_connect="SET collation_connection = utf8mb4_unicode_ci"
init_connect="SET NAMES utf8mb4"
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
lower_case_table_names=1
default-time-zone=Asia/Shanghai

进入到容器：docker exec -it mysql /bin/bash
进入Mysql客户端： mysql -h127.0.0.1 -uroot -p123456 -P3306
设置随Docker自启动 docker update mysql --restart=always

Docker compose 安装 mysql：

touch docker-compose-mysql.yml
docker compose -f docker-compose-mysql.yml up -d

version: '3'
services:
  mysql:
    image: mysql:5.7
    container_name: mysql
    environment:
      - MYSQL_ROOT_PASSWORD=123456
    volumes:
      - /home/docker/mysql/log:/var/log/mysql
      - /home/docker/mysql/data:/var/lib/mysql
      - /home/docker/mysql/conf:/etc/mysql/conf.d
      - /etc/localtime:/etc/localtime:ro
    ports:
      - 3306:3306
    restart: always

mysql8.0解决navicat 连接不上虚拟机报错：Client does not support authentication protocol requested by server; conside：

docker exec -it mysql /bin/bash
mysql -u root -p
# 这里的 password 是root密码
ALTER USER 'root'@'%' IDENTIFIED BY 'password ' PASSWORD EXPIRE NEVER;
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'password ';
FLUSH PRIVILEGES;

select user,host,plugin from user where user='root';

Docker搭建Mysql8.0.20服务

# 拉取镜像
docker pull mysql:8.0.20

# 创建挂载使用到的目录
mkdir -vp /home/docker/mysql3380
cd /home/docker/mysql3380
mkdir data logs conf

# 创建mysql容器
docker run -d -p 3380:3306 --name mysql3380 -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0.20

# 拷贝mysql的配置文件和数据
# 复制配置文件
docker cp mysql3380:/etc/mysql /home/docker/mysql3380/conf
# 复制data文件
docker cp mysql3380:/var/lib/mysql /home/docker/mysql3380/data

# 停止并删除容器
docker stop mysql3380
docker rm -f mysql3380

# 重新创建容器(指定数据卷)
docker run -d -p 3380:3306 \
--name mysql3380 \
--privileged=true \
--restart=unless-stopped \
-v /home/docker/mysql3380/conf/mysql/conf.d:/etc/mysql/conf.d \
-v /home/docker/mysql3380/logs:/var/log/mysql \
-v /home/docker/mysql3380/data/mysql:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:8.0.20

# 不允许远程连接解决方法
docker exec -it mysql /bin/bash
mysql -u root -p
use mysql;
# 更新root - localhost 为 root - %
update user set host = '%' where user = 'root' and host='localhost'; 
# 设置允许远程用户访问
GRANT ALL ON *.* TO 'root'@'%'; 
flush privileges;# 刷新权限
#更新用户加密方式，mysql8默认的加密方式
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '密码';

Docker搭建Mysql主从复制

上面我们已经创建了一个Mysql服务，这里作为主从中的master服务。
docker-compose部署mysql5.7、mysql 8、单点、双主

创建Mysql的slave服务

下面用同样的方式创建一个Mysql的slave服务。

# 注意修改主机端口号和容器名
sudo docker run -p 3381:3306 --name mysql3381 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

在这里插入图片描述
配置主从之前我们需要知道服务器的IP地址。

docker inspect --format='{{.NetworkSettings.IPAddress}}' mysql3380
docker inspect --format='{{.NetworkSettings.IPAddress}}' mysql3381

在这里插入图片描述
Master 服务器地址是 172.17.0.4 ，Slave 服务器地址是 172.17.0.5，MySQL 的端口号都为 3306。

配置master服务器

进入到 Master 服务器：docker exec -it mysql3380 bash
进入Mysql客户端： mysql -h127.0.0.1 -uroot -p123456 -P3306

修改配置文件： /etc/mysql/my.cnf

[mysqld]
## 设置server_id，一般设置为IP，同一局域网内注意要唯一
server_id=100  
## 复制过滤：也就是指定哪个数据库不用同步（mysql库一般不同步）
binlog-ignore-db=mysql  
## 开启二进制日志功能，可以随便取，最好有含义（关键就是这里了）
log-bin=edu-mysql-bin  
## 为每个session 分配的内存，在事务过程中用来存储二进制日志的缓存
binlog_cache_size=1M  
## 主从复制的格式（mixed,statement,row，默认格式是statement）
binlog_format=mixed  
## 二进制日志自动删除/过期的天数。默认值为0，表示不自动删除。
expire_logs_days=7  
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062

一般docker容器中没有vi或者其它相应的文本编辑器，如果只是为了修改这个配置文件就安装一个vi，太麻烦了，下面是另一种方案。
通过docker cp把这个文件拷贝出来： docker cp mysql3380:/etc/mysql/my.cnf /home/
再拷贝回去：docker cp /home/my.cnf mysql3380:/etc/mysql/

在容器中重启Mysql服务： service mysql restart
这个命令会使得容器停止，重新启动容器就可以了。

创建数据同步用户：

CREATE USER 'slave'@'%' IDENTIFIED BY '123456';
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%';

配置slave服务器

进入到 Master 服务器：docker exec -it mysql3381 bash
进入Mysql客户端： mysql -h127.0.0.1 -uroot -p123456 -P3306

[mysqld]
## 设置server_id，一般设置为IP,注意要唯一
server_id=101  
## 复制过滤：也就是指定哪个数据库不用同步（mysql库一般不同步）
binlog-ignore-db=mysql  
## 开启二进制日志功能，以备Slave作为其它Slave的Master时使用
log-bin=edu-mysql-slave1-bin  
## 为每个session 分配的内存，在事务过程中用来存储二进制日志的缓存
binlog_cache_size=1M  
## 主从复制的格式（mixed,statement,row，默认格式是statement）
binlog_format=mixed  
## 二进制日志自动删除/过期的天数。默认值为0，表示不自动删除。
expire_logs_days=7  
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062  
## relay_log配置中继日志
relay_log=edu-mysql-relay-bin  
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1  
## 防止改变数据(除了特殊的线程)
read_only=1

配置完成后重启mysql，和配置 Master 一样，会使容器停止，需要启动容器。

完成Master和Slave链接

在 Master 进入 MySQL，然后执行命令： show master status;
在这里插入图片描述
记录下 File 和 Position 字段的值，后面会用到。

然后到 Slave 中进入 mysql，执行命令：

change master to master_host='172.17.0.4', 
master_user='slave', 
master_password='123456', 
master_port=3306, 
master_log_file='edu-mysql-bin.000001', 
master_log_pos=2395, 
master_connect_retry=30;

master_host: Master 的IP地址
master_user: 在 Master 中授权的用于数据同步的用户
master_password: 同步数据的用户的密码
master_port: Master 的数据库的端口号
master_log_file: 指定 Slave 从哪个日志文件开始复制数据，即上文中提到的 File 字段的值
master_log_pos: 从哪个 Position 开始读，即上文中提到的 Position 字段的值
master_connect_retry: 当重新建立主从连接时，如果连接失败，重试的时间间隔，单位是秒，默认是60秒。

执行以下命令，开始开启主从同步： start slave;

在 Slave 的 MySQL 终端执行查看主从同步状态： show slave status \G;
在这里插入图片描述
SlaveIORunning 和 SlaveSQLRunning 是No，表明 Slave 还没有开始复制过程。相反 SlaveIORunning 和 SlaveSQLRunning 是Yes表明已经开始工作了，因为我已经运行过了，所以我的显示的都是 Yes。

Docker 安装 Redis

拉取Redis镜像

docker pull redis:7.2.3

Redis 配置文件
在这里插入图片描述
创建 redis.conf 配置文件，并将跳转网页中展示的所有配置项，复制到 redis.conf 文件中：

# 创建持久化数据目录
mkdir -p /home/docker/redis/data
# 创建配置文件目录
mkdir -p /home/docker/redis/conf
# 创建配置文件
touch /mydata/redis/conf/redis.conf

可以从官网下载配置文件后修改也可以直接在配置文件中填写：

# 关闭保护模式，允许远程连接
protected-mode no
# 开启AOF持久化
appendonly yes 
# 密码
requirepass 123456

修改 Redis 配置文件：
默认情况下，Redis 只监听来自本地的连接。通过注释掉 bind 127.0.0.1 -::1，Redis 将会监听所有网络接口上的连接，这意味着外部网络上的设备也可以连接到 Redis 服务器。这会使 Redis 变得可从外部访问，而不仅仅是从本地。
在这里插入图片描述
全局搜索关键词 requirepass , 将该配置项注释放开，并填写连接密码：

启动Redis容器

docker run -p 6379:6379 -d --name redis \
--restart=always \
-v /mydata/redis/data:/data \
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
redis:7.2.3 \
redis-server /etc/redis/redis.conf --appendonly yes

redis-server /etc/redis/redis.conf --appendonly yes：
这是容器启动后执行的命令。它启动 Redis 服务器，使用 /etc/redis/redis.conf 作为配置文件，–appendonly yes：启用 AOF 持久化模式。

启动Redis客户端

docker exec -it redis redis-cli

重启Redis服务

docker restart redis

设置随Docker自启动

docker update redis --restart=always

Docker compose 安装 Redis

拉取镜像和Redis配置文件参考上一章节。

编写docker-compose.yml编排文件：

# 在data、conf目录同级创建编排文件
touch docker-compose-redis.yml

version: '3'
services:
  redis:
    image: redis:7.2.3
    container_name: redis
    ports:
      - 6379:6379
    volumes:
      - /home/docker/redis/conf/redis.conf:/etc/redis/redis.conf
      - /home/docker/redis/data:/data
    restart: always
    privileged: true
    command: ["redis-server","/etc/redis/redis.conf"]

启动容器：

docker compose -f docker-compose-redis.yml up -d

Docker 安装 nginx

1、拉取镜像
去docker hub，找到nginx镜像。

# 下载最新版，版本：latest
docker pull nginx
# 镜像名:版本名（标签）
docker pull nginx:1.20.1
# 查看所有镜像
docker images  
# 删除镜像，如果存在容器，需要先删除容器
docker rmi 镜像名:版本号/镜像id

2、启动容器
启动nginx应用容器，并映射88端口。

# -d：后台运行
# --restart=always: 开机自启
docker run --name=mynginx -d --restart=always -p 88:80 nginx
# 测试地址
http://192.168.56.31:88/

# 查看正在运行的容器
docker ps
# 查看所有
docker ps -a
# 删除停止的容器
docker rm  容器id/名字
# 强制删除正在运行中的容器
docker rm -f mynginx 

# 停止容器
docker stop 容器id/名字
# 再次启动
docker start 容器id/名字

# 应用开机自启
docker update 容器id/名字 --restart=always

3、修改容器内容
修改默认的index.html 页面。

# 进入容器内部的系统，修改容器内容
docker exec -it 容器id/名字  /bin/bash

4、将修改后的容器制作成新镜像
将自己修改好的镜像提交。

# 将修改好的镜像制作成一个新的镜像
docker commit -a "yangqian" -m "首页变化" 2b5a8c4d1b76  yqnginx:v1.0

# 将镜像保存成压缩包
docker save -o abc.tar yqnginx:v1.0

# 别的机器加载这个镜像
docker load -i abc.tar

5、挂载数据

# 挂载数据到外部修改
docker run --name=mynginx \
-d  --restart=always \
-p  88:80 -v /data/html:/usr/share/nginx/html:ro \
nginx

# 修改页面只需要去 主机的 /data/html
[root@centos7-node1 ~]# cd /data/html/
[root@centos7-node1 html]# echo "hello world" > index.html

6、扩展命令

# 查看日志，进行排错
docker logs 容器名/id   
# 进入容器
docker exec -it 容器id /bin/bash

# docker 经常修改 nginx 配置文件，需要提前准备好 nginx.conf 配置文件
docker run -d -p 80:80 \
-v /data/html:/usr/share/nginx/html:ro \
-v /data/conf/nginx.conf:/etc/nginx/nginx.conf \
--name mynginx \
nginx


# 把容器指定位置的东西复制出来 
docker cp 5eff66eec7e1:/etc/nginx/nginx.conf  /data/conf/nginx.conf
# 把外面的内容复制到容器里面
docker cp  /data/conf/nginx.conf  5eff66eec7e1:/etc/nginx/nginx.conf

Docker 安装 Elasticsearch、Kibana

# 存储和检索数据
docker pull elasticsearch:7.4.2
# 可视化检索数据
docker pull kibana:7.4.2

mkdir -p /home/docker/elasticsearch/config
mkdir -p /home/docker/elasticsearch/data
chmod -R 777 /home/docker/elasticsearch
echo "http.host: 0.0.0.0" >> /home/docker/elasticsearch/config/elasticsearch.yml

# 访问地址 http://192.168.56.11:9200/
# 查看节点信息 http://192.168.56.11:9200/_cat/nodes
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /home/docker/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /home/docker/elasticsearch/data:/usr/share/elasticsearch/data \
-v /home/docker/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2

# 访问地址 http://192.168.56.11:5601/
docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.56.11:9200 -p 5601:5601 \
-d kibana:7.4.2

Docker 运行 Java 应用

示例代码：https://gitee.com/leifengyang/java-demo.git

1、以前开发流程

编写一个SpringBoot应用。
SpringBoot 打包成可执行 jar。
把 jar 包上传给服务器。
服务器需要安装 Java。
服务器运行应用 java -jar。

缺点： 需要安装 Java 运行环境，如果在别的机器运行这个应用的话，需要提前准备好 Java 环境。

2、现在
机器都安装Docker，任何应用都认为是一个镜像，所有机器都可以运行。

3、打包成镜像
（1）SpringBoot 打包成可执行 jar，并上传到服务器。
（2）编写 Dockerfile 文件进行打包。

# 基础镜像
FROM openjdk:8-jdk-slim
# 设定时区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 拷贝jar包
COPY hello.jar /app.jar
# 入口
ENTRYPOINT ["java","-jar","/app.jar"]

# 构建镜像
docker build -t java-demo:v1.0 .
# 运行
docker run -d -p 8080:8080 --name myjava-app java-demo:v1.0
# 查看日志
docker logs -f [容器id]

优点： 运行应用无需安装运行环境，运行镜像即可，因为镜像已经集成了运行环境。

Docker 推送镜像到阿里云

参考： Docker push镜像到阿里云

1、登录阿里云
登录阿里云 >> 进入控制台 >> 搜索容器镜像服务
https://cr.console.aliyun.com/cn-hangzhou/instances
在这里插入图片描述
创建个人实例（上图已创建）>> 进入个人实例。

创建命名空间。

使用命名空间创建仓库（一个仓库对应一个docker镜像）>> 提交时选择本地仓库 >> 在镜像仓库列表点击管理操作（操作指南）。

根据下面的操作指南操作即可：
在这里插入图片描述

Docker 自定义镜像

Docker 安装 Kafka

拉取zookeeper、kafka镜像：

docker save -o kafka.tar kafka
docker load -i kafka.tar

docker pull wurstmeister/zookeeper
docker pull wurstmeister/kafka

docker pull wurstmeister/zookeeper:3.4.6
docker pull wurstmeister/kafka:2.13-2.8.1

分别启动zookeeper、kafka容器：

docker run -d --name zookeeper -p 2181:2181 wurstmeister/zookeeper
docker run -d --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=【IP地址】:2181/kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://【IP地址】:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 wurstmeister/kafka

docker run -d --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=139.198.28.176:2181/kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://139.198.28.176:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 wurstmeister/kafka

docker run -d --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=192.168.56.12:2181/kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.56.12:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 wurstmeister/kafka

查看kafka日志：

docker logs -f kafka

使用docker-compose方式安装kafka：
创建 docker-compose.yml 文件：

version: '3'
services:
  zookeeper:
    image: wurstmeister/zookeeper
    container_name: zookeeper
    mem_limit: 256M
    ports:
      - 2182:2181

  kafka:
    image: wurstmeister/kafka
    container_name: kafka
    ports:
      - 9093:9092
    environment:
      KAFKA_ZOOKEEPER_CONNECT: 47.103.107.69:2182/kafka
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://47.103.107.69:9093
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092
      KAFKA_HEAP_OPTS: "-Xmx256M -Xms16M"
    depends_on:
      - zookeeper

在docker-compose.yml 文件目录执行：

docker-compose up -d

kafka相关命令：

# 进入kafka容器
docker exec -it kafka /bin/bash
cd /opt/kafka/bin
./kafka-topics.sh --list --bootstrap-server localhost:9092
./kafka-topics.sh --create --topic my-topic --bootstrap-server localhost:9092
./kafka-topics.sh --describe --topic my-topic --bootstrap-server localhost:9092
./kafka-consumer-groups.sh --bootstrap-server localhost:9092 --list
./kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group my-group

Docker 安装 nacos

nacos镜像地址
 Docker安装nacos2.2.0并开启鉴权
 Docker安装nacos2.2.3

docker pull nacos/nacos-server:v2.4.1
# 启动一个单机模式的Nacos服务
docker run -d --name nacos -p 8848:8848 -e MODE=standalone nacos/nacos-server

-d 表示以守护进程方式运行容器；
–name nacos 给容器命名为nacos；
-p 8848:8848 将容器的8848端口映射到宿主机的8848端口；
-e MODE=standalone 设置环境变量，指定Nacos以单机模式运行；

Nacos2.2.2之前版本默认的控制台，无论服务端是否开启鉴权，都会存在一个登录页。
Nacos2.2.2之后版本开始，在未开启鉴权时，默认控制台将不需要登录即可访问，同时在控制台中给予提示，提醒用户当前集群未开启鉴权。

# 挂载nacos容器内部conf和logs这两个目录下的文件
mkdir -p /home/docker/nacos/conf
mkdir -p /home/docker/nacos/logs

# 创建临时Nacos容器(会删除)，将容器内部conf和logs下的文件拷贝到宿主机，这一步一定要做
docker run -d --name nacos -p 8848:8848 -e MODE=standalone nacos/nacos-server
docker cp nacos:/home/nacos/logs /home/docker/nacos
docker cp nacos:/home/nacos/conf /home/docker/nacos
# 删除Nacos容器
docker rm -f nacos
docker logs -f nacos

# 创建nacos容器并开启鉴权
docker run -d --name nacos \
-p 8848:8848 \
-p 9848:9848 \
-p 9849:9849 \
-e JVM_XMS=256m \
-e JVM_XMX=256m \
-e MODE=standalone \
-e NACOS_AUTH_ENABLE=true \
-e NACOS_AUTH_TOKEN=SecretKey01234567890123456789012345345678999987654901234567890123456789 \
-e NACOS_AUTH_IDENTITY_KEY=nacos \
-e NACOS_AUTH_IDENTITY_VALUE=nacos \
-v /home/docker/nacos/conf:/home/nacos/conf \
-v /home/docker/nacos/logs:/home/nacos/logs \
--restart=always \
nacos/nacos-server:v2.4.1

8848：这是Nacos服务的主端口，用于客户端、控制台以及OpenAPI的HTTP通信。
9848：客户端gRPC请求服务端的端口，客户端通过此端口向Nacos服务端发起连接和请求。
9849：服务端gRPC请求服务端的端口，主要用于服务间的同步等操作。

nacos配置文件：

docker exec -it nacos bash
cd /home/nacos/conf
vim application.properties
# 开启鉴权配置
nacos.core.auth.plugin.nacos.token.secret.key=${NACOS_AUTH_TOKEN:SecretKey01234567890123456789012345345678999987654901234567890123456789}
nacos.core.auth.server.identity.key=${NACOS_AUTH_IDENTITY_KEY:admin}
nacos.core.auth.server.identity.value=${NACOS_AUTH_IDENTITY_VALUE:admin}
##新增两行
nacos.core.auth.enabled=true
nacos.core.auth.enable.userAgentAuthWhite=false

Docker compose 安装 Nacos：

touch /home/docker/nacos/docker-compose.yml
docker compose -f docker-compose.yml up -d
docker logs -f nacos
# docker-compose.yml:
version: '3'
services:
  nacos:
    image: nacos/nacos-server:v2.4.1
    container_name: nacos
    ports:
      - 8848:8848
      - 9848:9848
      - 9849:9849
    environment:
      - MODE=standalone
      - TZ=Asia/Shanghai
      - JVM_XMX=128m
      - JVM_XMS=128m
      - NACOS_AUTH_ENABLE=true
      - NACOS_AUTH_TOKEN=SecretKey01234567890123456789012345345678999987654901234567890123456789
      - NACOS_AUTH_IDENTITY_KEY=nacos
      - NACOS_AUTH_IDENTITY_VALUE=nacos
    volumes:
      - /home/docker/nacos/conf:/home/nacos/conf
      - /home/docker/nacos/logs:/home/nacos/logs
    restart: always