linux-docker

unix liunx windows

# linux
	 文件系统 

    所有的资源都是目录在 /root 根目录下

## 一. 指令
    ip addr/ifconfig, cd, ls, vim
    sudo - 管理员身份
    \ - 代表换行输入
    pwd - 查看所在目录
    sudo systemtcl stop firewalld.service
    防火墙:
        firewall-cmd --state  防火墙状态
        systemctl enable/disable firewalld.service   防火墙开机自启/关闭
        systemctl start/stop firewalld.service       手动开启/关闭防火墙
        firewall-cmd --list-ports

---
### go语言
### shell编程
---
# docker
> 1.概述 

    官网: https://vuepress.mirror.docker-practice.com   https://docs.docker.com/get-started/overview/

> 2.在docker中安装的是 服务的容器 如: mysql容器(可移植)

> 3.docker运行机制

    Client 客户端-指令
    Docker Host 宿主机   images,docker daemon
        Containers  容器
        images      本地的镜像仓库
        Docker daemon docker的服务线程,处理客户端命令
    Registry    远程的镜像仓库

## 一. docker指令
> 1.基础指令

    docker build 创建镜像文件-images-到镜像服务器
    docker pull  从镜像服务器拿到本地
    docker run   运行容器-将镜像文件在容器中运行

> 2.克隆

    克隆之后的使用空间小,
    原始的linux可以再次克隆使用,

> 3.Yum 在线安装 仓库如:maven    包管理器

    1.卸载旧版
        sudo yum remove docker-ce docker-ce-client docker-client-latest docker-common docker-latest docker-latest-logrotate docker-logrotate docker-engine
    2.安装一组工具
        sudo yum install -y yum-utils
    3.设置yum仓库
        sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
        sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    4.更新yum缓存
        sudo yum makecache fast

> 4.docker

    1.安装docker
        sudo yum install -y docker-ce docker-ce-cli containerd.io
        docker -v  查看docker
    2.启动docker
        sudo systemctl start/stop docker
    3.设置开机自启
        sudo systemctl enable/disenable docker
    4.镜像加速 - 修改配置文件 /etc/docker/daemon.json
        镜像-docker的Registry, 
        cat <<EOF > /etc/docker/daemon.json
        {
        "registry-mirrors": [
            "https://docker.mirrors.ustc.edu.cn",
            "http://hub-mirror.c.163.com"
        ],
        "max-concurrent-downloads": 10,
        "log-driver": "json-file",
        "log-level": "warn",
        "log-opts": {
            "max-size": "10m",
            "max-file": "3"
            },
        "data-root": "/var/lib/docker"
        }
        EOF
    5.重新加载docker配置
        sudo systemctl daemon-reload
    6.重启docker服务
        sudo systemctl restart docker
    7.查看镜像配置
        docker info
    8.验证docker 运行hello-world镜像
        sudo docker run hello-world   --会先下载镜像,启动容器containers
    9.检查docker本地镜像          docker images
    10.检查已启动docker镜像       docker ps
    11.查看所有docker镜像         docker ps -all
    12.停止docker某镜像服务       docker stop 服务id
    13.删除docker镜像
        docker image rm hello-world
    14.删除被占用的镜像-先删容器
        docker container rm 容器name/容器id
    15.docker镜像仓库
        https://hub.docker.com
    16.在docker镜像仓库下载资源(镜像文件)
        如: docker pull hello-world

> 5. 离线安装docker

    1.docker离线包
        https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz
    2.离线安装工具
        https://github.com/Jrohy/docker-install/
    3.拷贝到centos
        # 进入 docker-install 文件夹
        cd docker-install

        # 为 docker-install 添加执行权限
        chmod +x install.sh

        # 安装
        ./install.sh -f docker-20.10.6.tgz
    4.镜像加速
        cat <<EOF > /etc/docker/daemon.json
        {
        "registry-mirrors": [
            "https://docker.mirrors.ustc.edu.cn",
            "http://hub-mirror.c.163.com"
        ],
        "max-concurrent-downloads": 10,
        "log-driver": "json-file",
        "log-level": "warn",
        "log-opts": {
            "max-size": "10m",
            "max-file": "3"
            },
        "data-root": "/var/lib/docker"
        }
        EOF
    5.重启docker
        # 重新加载docker配置
        sudo systemctl daemon-reload
        #重启docker服务
        sudo systemctl restart docker
	6.确认安装
        docker info
        docker run hello-world

## 二. 核心对象
> 1.镜像

    包含: 程序, 库, 资源, 配置, 配置参数(匿名卷,环境变量,用户)
    组成: 多层文件系统联合组成
    构建: 一层一层构建, 每一层包含该层需要的的东西, 构建后删除的文件只是标记删除了, 任何额外的东西在构建结束前删掉

> 2.容器

    容器是镜像运行时的载体, 
    创建, 启动, 停止, 删除, 暂停
    本质: 进程, 但和宿主机不同
    容器拥有: root文件系统, 网络配置, 进程空间, 用户id空间
    特性: 容器封装运行的应用比直接在宿主机运行更加安全

> 3.数据卷

    存储层: 容器运行自动创建, 随着容器消亡而消亡
    数据卷: 所有文件的写入操作, 读写跳过容器存储层
        特性: 1)性能稳定性更高, 2)独立于容器, 3)不会随着容器的额消亡而消亡

## 三. docker镜像操作
    docker pull centos:7
    docker images / docker image ls
    运行一个镜像创建容器: 
    docker run -it xxx(名/id) bash
        说明: -it i:交互式操作 t:终端, bash:进入程序,命令行窗口
    exit - 退出当前容器centos
    保存镜像:
        1) 本地创建目录: mkdir -p setup/centos -创建多级目录
        2) 导出/保存镜像: docker save centos:7 | gzip
        3) 导入镜像: docker load < centos7.tar.gz
## 四. docker容器操作
	第一次:使用镜像创建容器
	    运行:           docker run -it centos:7 bash
	    后台运行:       docker run -d centos:7
	    后台运行容器输出结果: docker ccontainer logs 802
	创建容器之后运行:
	    运行/停止/重启:           docker container start/stop/restart 802
	    进入指定容器:    docker exec -it 802 bash
	    删除运行中容器:  docker container rm -f 802
	    清理所有终止状态容器: docker container prune

## 五. docker数据卷操作
    1.容器中管理数据 
        1) 挂载书籍目录(docker run -v 宿主机目录:容器目录)
        2) 数据卷, 创建时也是存储在宿主机目录
    2.特殊目录, 容器之间共享
    3.操作
        a.创建数据卷: docker volume create container-vol
        b.查看:       docker volume ls
        c.查看指定数据卷信息: docker volume inspect container-vol
        d.启动挂载数据卷的容器:
            docker run -it --mount source=container-vol,target=/root centos:7 bash
            docker run -it -v container-vol:/root centos:7 bash
        e.删除: docker voiume rm container-vol
        f.清理: docker volume prune

        g.挂载主机目录: 
            docker run -it -v /usr/app:/opt/app centos:7 bash
        h.查看挂载目录:
            docker inspect 容器id
        
        

        i.数据卷与容器
            创建数据卷   docker volume create container-vol
            -> 启动挂载数据卷的容器    docker run -it -v container-vol:/root centos:7 bash    解释: container-vol:/root中 container-vol是宿主机目录,/root是容器中的目录     
            -> 进入容器打开挂载点目录  cd /root
            -> 挂载点目录下创建文件    touch hello.java
            -> 退出容器                exit
            -> 在本地目录(Mountpoint)下可以找到创建的文件
                                        cd /var/lib/docker/volumes/container-vol/_data
            启动容器  docker start 容器id
            -> 进入容器          docker exec -it 容器id bash
            -> 进入挂载点目录    cd /root
            -> 创建文件          touch nihao.java
            -> 退出容器                exit
            -> 在本地目录(Mountpoint)下可以找到创建的文件
                                        cd /var/lib/docker/volumes/container-vol/_data

        j.挂载主机目录 与 容器
            docker run -it -v /usr/app:/opt/app centos:7 bash

            已存在的容器挂载主机目录 ???????
        
        k.查看 数据卷/容器 信息
            docker volume inspect container-vol
            docker inspect 容器id

## 六. Dockerfile文件
    1.概述
        dockerfile文件是用来构建镜像的文本文件, 
## 七. 制作镜像  jdk
    1.准备
        1) centos:7镜像
        2) jdk压缩包 jdk-8u51-linux-x64.tar.gz
    2.Dockerfile文件
        创建: touch Dockerfile  ---Dockerfile 和资源放在一起 
        打开: vim Dockerfile
        编辑:
            FROM centos:7
            ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker   
                    --通过ADD命令将宿主机中的压缩包传入镜像容器中的指定目录,并同时解压缩
            ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH
                        --设置环境变量(通过ENV关键字实现，目录启动容器中的目录)
            CMD [‘bash’]    --指定命令行操作(所有指令与后面内容要有空格)

	Dockerfile文件内容:
		FROM centos:7
		ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker
		ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 \
		    PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH
		CMD ['bash']

    3.构造镜像
        docker build -t jdk:8 .    --使用 Dockerfile 构建镜像(在Dockerfile所在目录执行docker指令)

    4.运行
        docker run -it jdk:8 bash

    5.查看镜像
        docker info

    6. 导出: docker save  jdk:8 | gzip > jdk8.tar.gz  
    7. 导入: docker load < jdk8.tar.gz
    
    8.jvm虚拟机 oracle
        java HotSpot(TM) 64-Bit Server VM (build 25.51-b03, mixed mode)

    9.运行java程序
        javac -d . Hello.java
        java 包名.Hello 
    
    10.制作sentinel镜像
		FROM centos:7
		ADD jdk-8u51-linux-x64.tar.gz  /usr/local/
		ADD sentinel-dashboard-1.8.0.jar  /usr/local/
		ENV JAVA_HOME=/usr/local/jdk1.8.0_51 \
		    PATH=/usr/local/jdk1.8.0_51/bin:$PATH
		EXPOSE 8080
		ENTRYPOINT ["java","-jar","/usr/local/sentinel-dashboard-1.8.0.jar"]
	11.制作镜像:
		docker build -t sentinel:8 .
	12.运行:
		docker run -d -p 8180:8080 --name sentinel  \
		-v /usr/local/docker/sentinel/logs:/root/logs/csp sentinel:8
          


## 六. 部署的服务 的指令
> 1.jdk
###
    a. centos:7
    b. jdk-8u51-linux-x64.tar.gz
    c. Dockerfile
    d. docker build -t jdk:8 .
    e. docker run -it jdk:8 bash
> 2.sentinel
###
    a. 拷贝sentinel文件
    b. 运行
		docker run –d  -p 8180:8080 --name sentinel \
		–v /root/mytest/sentinel:/usr/sca jdk:8 \
		java –jar /usr/sca/sentinel-dashboard-1.8.0.jar
		        说明: /root/mytest/sentinel:/usr/sca jdk:8 java –jar /usr/sca/sentinel-dashboard-1.8.0.jar
		                jar包所在位置(本地目录) : 容器 /usr/sca
> 3.mysql
###
    a. 官网 拉取 sudo docker pull mysql:8.0.23
    b. sudo docker images
    c. 启动
			sudo docker run -p 3306:3306 --name mysql \
			-v /usr/local/docker/mysql/mysql-files:/var/lib/mysql-files \
			-v /usr/local/docker/mysql/conf:/etc/mysql \
			-v /usr/local/docker/mysql/logs:/var/log/mysql \
			-v /usr/local/docker/mysql/data:/var/lib/mysql \
			-e MYSQL_ROOT_PASSWORD=root \
			-d mysql:8.0.23

    d. docker start/stop/restart mysql
    e. 进入mysql容器 sudo docker exec -it mysql bash
    f. mysql -uroot -proot
    g. 开机自启 docker update mysql --restart=always
    h. whereis mysql
    i. window连接linux的mysql
        create user 'zhaoqing'@'%' identified by 'zhaoqing';
        grant all on *.* to 'zhaoqing'@'%';
        window平台:
            mysql -uzhaoqing -h192.168.126.132 -pzhaoqing
        出错:
            ALTER USER 'tony'@'%' IDENTIFIED BY 'tony' PASSWORD EXPIRE NEVER;
            ALTER USER 'tony'@'%' IDENTIFIED WITH mysql_native_password BY 'tony'; 
            FLUSH  PRIVILEGES;

> 4.redis
###
    a. docker pull redis
    b. mkdir -p /root/mytest/redis/01/conf
    c. touch /root/mytest/redis/01/conf/redis.conf
    d. docker run -p 6379:6379 --name redisone \
       -v /root/mytest/redis/one/data:/data \
       -v /root/mytest/redis/one/conf/redis.conf:/etc/redis/redis.conf \
       -d redis redis-server /etc/redis/redis.conf
    e. docker exec -it redisone bash
    f. Redis-server -v / redis-cli -v
    g. 登录: redis-cli   / docker exec -it redis redis-cli
    h. docker start/restart/stop redis

> 5.nginx
### 
    a. docker pull nginx
    b. docker run -p 80:80 --name nginx -d nginx
    c. docker exec nginx ls -l /etc/nginx
    d. 拷贝配置文件: docker cp -a nginx:/etc/nginx /root/mytest/nginx
    e. 删除: docker rm -f nginx
    f. 启动:
		sudo docker run -p 80:80 --restart always --name nginx \
		-v /root/mytest/nginx/:/etc/nginx/ \
		-v /root/mytest/nginx/conf.d:/etc/nginx/conf.d \
		-d nginx
    g. 修改配置:
        直接在本地目录对应的位置修改

> 6.nacos
###
    a. docker pull nacos/nscos-server:1.4.1
    b. nacos的数据库 nacos-mysql.sql 使用mysql执行
        /var/lib/mysql-files      /usr/local/docker/mysql/mysql-files
        cp nacos-mysql.sql  /usr/local/docker/mysql/mysql-files/nacos-mysql.sql
    c. 启动
			docker run  \
			-e TZ="Asia/Shanghai" \
			-e MODE=standalone \
			-e SPRING_DATASOURCE_PLATFORM=mysql \
			-e MYSQL_DATABASE_NUM=1 \
			-e MYSQL_SERVICE_HOST=192.168.126.132 \
			-e MYSQL_SERVICE_PORT=3306 \
			-e MYSQL_SERVICE_USER=root \
			-e MYSQL_SERVICE_PASSWORD=root \
			-e MYSQL_SERVICE_DB_NAME=nacos_config \
			-p 8848:8848 \
			--name nacos \
			--restart=always \
			-d nacos/nacos-server:1.4.1

    d. 日志: 容器内  /home/nacos/logs/start.out
        docker container logs 容器id




---
# 需要部署的服务
    镜像--centos:7
    jdk  --自己构建镜像
    mysql
    sentinel
    redis
    nginx
    nacos

	-e
	-i -t -d 
	-v 
	-p


# linux部署服务  学的
1. 克隆centos7(在克隆的宿主机中部署)
2. yum         卸载,安装,仓库,更新缓存
3. docker      yum安装,启动,开机自启,镜像加速,重新加载配置,重启,
4. images      镜像. 拉取,创建,运行,导出,导入
5. container   容器. 运行镜像创建容器,运行,停止,进入,删除,清理所有
6. volume      数据卷. 创建,查看,查看信息,启动挂载数据卷的容器,删除,清理
7. 挂载宿主机目录  挂载,查看
8. 制作镜像     centos:7,jdk压缩包,Dockerfile
9. jdk          centos:7,jdk压缩包,Dockerfile
10. mysql       pull,run,exec,登录
11. sentinel    jdk:8运行jar包
12. redis       pull,挂载,运行,exec,登录
13. nginx       pull,运行,配置文件,删除,挂载运行
14. nacos       pull,数据库,启动,日志
15. 容器互联     宿主机通讯/虚拟网络
16. 虚拟网络     创建,创建容器加入虚拟网络



# Docker容器互联  -> redis集群
> nacos连接数据库  
    8848 -> nacos -> 3306 -> mysql
## yi.通过宿主机进行通讯
    容器中的端口映射到宿主机
    其他容器通过 映射到宿主机上的端口 进行访问别的容器
## er.容器之间直接通过虚拟网络,在docker中创建网络
    1. docker 中创建网络
        docker network create -d bridge 网络名    -d driver,网络类型，默认 bridge
    2. 查看 
        docker network ls
        docker inspect 网络id
    3. 创建容器 加入 t-net 网络
        终端1   docker run -it --name app1 --network t-net centos:7
        终端2   docker run -it --name app2 --network t-net centos:7
    4. 测试
        ping app1  ping app2





---
## Docker
### 安装的 image containers volumes network
### -> 存放在宿主机 /var/lib/docker 下
    docker history sentinel:8
---