首页 > 其他分享 >docker命令

docker命令

时间：2023-06-09 16:35:36浏览次数：54  
标签：compose service -- image 命令 mysql docker

Docker

#常用命令

(1)查看运行情况
    docker ps -a

(2)日志查看
    docker logs -f IMAGE

(3)进入容器
    docker exec -it IMAGE sh

(4)删除容器
    docker rm -f IMAGE

(5)退出容器
    exit

(6)下载镜像
    docker pull name:tag

(7)查看本地已下载的镜像
    docker images

(8)删除镜像
    docker image rm imageid
    docker rmi -f imageId
    docker rmi -f $(docker image ls)

(9)从容器里面拷文件到宿主机
    docker cp 容器名：要拷贝的文件在容器里面的路径       要拷贝到宿主机的相应路径 
    docker cp mysql:/super_app.sql /home

(10)从宿主机拷文件到docker容器里面
    docker cp 要拷贝的文件路径 容器名：要拷贝到容器里面对应的路径
    
(11)发布镜像
    docker push
    
(12)查看版本
    docker-compose version
    
(13)根据yml创建service
    指定yaml：docker-compose up -f xxx.yaml
    后台运行：docker-compose up
    
(14)删除service[同时会删除掉network和volume]
    docker-compose down
    
(15)清理容器多余数据
    仅仅清除没有被容器使用的镜像文件：
    docker image prune -af   
    清除多余的数据，包括停止的容器、多余的镜像、未被使用的volume等：
    docker system prune -f  

(16)docker的logs的清理有什么好的方法吗？
    运行久了发现logs比镜像还大
    配置 docker 的 log-opts 参数
    设置每个容器产生的日志文件大小和数量
    
(17)查看镜像构建历史
    docker history
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
57
58
59

#yum

(1)更新yum
    yum update
    
(2)安装 yum-util
    yum install -y yum-utils

(3)添加yum源
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    yum-config-manager --add-repo http://download.docker.com/linux/centos/docker-ce.repo

(4)更新索引
    centos7：yum makecache fast
    centos8：yum makecache
1
2
3
4
5
6
7
8
9
10
11
12
13

#Docker安装

(1)卸载之前的docker
	sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
                  
(2)安装必要的依赖 
	sudo yum install -y yum-utils \
    device-mapper-persistent-data \
    lvm2

(3)设置docker仓库  
	sudo yum-config-manager \
      --add-repo \
      https://download.docker.com/linux/centos/docker-ce.repo
      
    [访问阿里云，使用自己的阿里云账号登录，查看菜单栏左下角，镜像加速器，使用下面的命令]
    
(4)安装docker
	sudo yum install -y docker-ce docker-ce-cli containerd.io

(5)启动
	sudo systemctl start docker

(6)测试docker安装是否成功
	sudo docker run hello-world
	
(7)设置为docker开机自启动
    chkconfig docker on
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

阿里云镜像加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://y11mlmqb.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6
7
8

#Dockerfile

FROM	
    Dockerfile 除了注释第一行必须是 FROM ，FROM 后面跟镜像名称，代表我们要基于哪个基础镜像构建我们的容器。
    例：FROM ubuntu:14.04

RUN	
    RUN 后面跟一个具体的命令，类似于 Linux 命令行执行命令。
    在镜像内部执行一些命令，比如安装软件，配置环境等。  
    例：groupadd -r mysql && useradd -r -g mysql mysql

ADD	
    将主机的文件复制到镜像内，和COPY类似，只是 ADD 会对压缩文件提取和解压
    ADD application.yml /etc/test/

COPY	
    将主机的文件复制到镜像内，如果目录不存在，会自动创建所需要的目录，注意只是复制，不会提取和解压。  
    COPY docker-entrypoint.sh /usr/local/bin/

USER	
    指定容器启动的用户

ENTRYPOINT	
    容器的启动命令
    和CMD的使用类似。和CMD的不同 docker run 执行时，会覆盖 CMD 的命令，而 ENTRYPOINT 不会。  
    ENTRYPOINT ["docker-entrypoint.sh"]  

CMD	
    CMD 为 ENTRYPOINT 指令提供默认参数，也可以单独使用 CMD 指定容器启动参数
    容器启动的时候默认会执行的命令，若有多个CMD命令，则最后一个生效。  
    CMD ["mysqld"] 或 CMD mysqld

ENV	
    指定容器运行时的环境变量，格式为 key=value
    可以通过docker run --e key=value修改，后面可以直接使用 ${MYSQL_MAJOR}。   

ARG	
    定义外部变量，构建镜像时可以使用 build-arg = 的格式传递参数用于构建

EXPOSE	
    指定容器监听的端口，格式为 [port]/tcp 或者 [port]/udp
    指定镜像要暴露的端口，启动镜像时，可以使用 -p 将该端口映射给宿主机。  
    EXPOSE 3306  

WORKDIR	
    为 Dockerfile 中跟在其后的所有 RUN、CMD、ENTRYPOINT、COPY 和 ADD 命令设置工作目录。
    指定镜像的工作目录，之后的命令都是基于此目录工作，若不存在则创建。  

    会在/usr/local/tomcat下创建test.txt文件。  
    WORKDIR /usr/local
    WORKDIR tomcat
    RUN touch test.txt
    
    会在/root/test下多出一个app.yml文件。  
    WORKDIR /root  
     ADD app.yml test/  
    
LABEL
    设置镜像标签。  
    LABEL email="[email protected]"
    LABEL name="xxx"
    
VOLUME
    指定数据的挂载目录。  
    VOLUME /var/lib/mysql
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
57
58
59
60
61
62
63

#举例

(1)创建一个Spring Boot项目

(2)写一个controller
  @RestController
  public class DockerController {
    @GetMapping("/dockerfile")
    @ResponseBody
    String dockerfile() {
    return "hello docker" ;
   }
 }
 
(3)mvn clean package打成一个jar包
在target下找到"dockerfile-demo-0.0.1-SNAPSHOT.jar"

(4)在docker环境中新建一个目录"first-dockerfile"

(5)上传"dockerfile-demo-0.0.1-SNAPSHOT.jar"到该目录下，并且在此目录创建Dockerfile

(6)创建Dockerfile文件，编写内容
    FROM openjdk:8
    MAINTAINER [email protected]
    LABEL name="dockerfile-demo" version="1.0" author="xxx"
    COPY dockerfile-demo-0.0.1-SNAPSHOT.jar dockerfile-image.jar
    CMD ["java","-jar","dockerfile-image.jar"]

(7)基于Dockerfile构建镜像
    docker build -t test-docker-image .

(8)基于image创建container
    docker run -d --name user01 -p 6666:8080 test-docker-image

(9)查看启动日志docker logs user01

(10)宿主机上访问curl localhost:6666/dockerfile
hello docker

(11)还可以再次启动一个
    docker run -d --name user02 -p 8081:8080 test-docker-image
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

#docker-composes搭建

#离线安装

(1)运行以下命令下载最新版本的docker-compose并进行安装  
    sudo curl -L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
    
(2)更改二进制文件的权限，使其能够运行
    chmod +x /usr/local/bin/docker-compose
    
(3)测试安装
    docker-compose --version
1
2
3
4
5
6
7
8

#在线安装

(1)安装python源
    apt-get update
    apt-get install python-pip

(2)删除老版docker-compose
    pip uninstall docker-compose

(3)安装docker-compose
    pip install docker-compose

(4)测试安装
    docker-compose --vesion
1
2
3
4
5
6
7
8
9
10
11
12

#镜像仓库

#docker hub

(1)在docker机器上登录
    docker login
(2)输入用户名和密码

(3)给image重命名，并删除掉原来的
    [注意镜像名称要和docker id一致，不然push不成功]
    docker tag test-docker-image rcbb/test-docker-image
    docker rmi -f test-docker-image
    
(4)再次推送，刷新hub.docker.com后台，发现成功
    docker push itcrazy2018/test-docker-image

(5)别人下载，并且运行
    docker pull itcrazy2018/test-docker-image
    docker run -d --name user01 -p 6661:8080 itcrazy2018/test-docker-image
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#阿里云docker hub

阿里云docker仓库

https://cr.console.aliyun.com/cn-hangzhou/instances/repositories

参考手册

https://cr.console.aliyun.com/repository/cn-hangzhou/dreamit/image-repo/details

(1)登录到阿里云docker仓库
    sudo docker login [email protected] registry.cn-hangzhou.aliyuncs.com
(2)输入密码

(3)创建命名空间，比如itcrazy2016

(4)给image打tag
    sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/itcrazy2016/test-docker-image:v1.0

(5)推送镜像到docker阿里云仓库
    sudo docker push registry.cn-hangzhou.aliyuncs.com/itcrazy2016/test-docker-image:v1.0
(6)别人下载，并且运行
    docker pull registry.cn-hangzhou.aliyuncs.com/itcrazy2016/test-docker-image:v1.0
    docker run -d --name user01 -p 6661:8080 registry.cn-hangzhou.aliyuncs.com/itcrazy2016/test-docker-image:v1.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

#搭建自己的Docker Harbor

(1)访问github上的harbor项目
    https://github.com/goharbor/harbor

(2)下载版本，比如1.7.1
    https://github.com/goharbor/harbor/releases

(3)找一台安装了docker-compose[这个后面的课程会讲解]，上传并解压
    tar -zxvf xxx.tar.gz
    tar xvf harbor-offline-installer-v2.5.0.tgz
    
(4)进入到harbor目录
    mv harbor.yml.tmpl harbor.yml
    修改 harbor.yml 文件：
    1.hostname 地址的修改成当前机器的ip地址；
    2.https 不用则注释掉；
    3.可以修改Harbor的密码，默认是 Harbor12345；（admin/Harbor12345）

(5)安装harbor，需要一些时间
    sh install.sh

(6)浏览器访问，比如 39.100.39.63，输入用户名和密码即可


(1)关闭实例
    docker-compose down -v

(2)启动Harbor
    docker-compose up -d
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

#Docker compose实现

(1)新建目录
    mkdir -p /apps/composetest
    cd /apps/composetest
    
(2)编写 app.py 代码
    vi app.py

(3)新建 requirements.txt 文件
    vi requirements.txt
    
(4)编写Dockerfile
    vi Dockerfile
    
(5)编写docker-compose.yaml文件
    vi docker-compose.yaml
    
(6)通过docker compose创建容器
    docker-compose up -d
    
(7)访问测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

app.py

import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

requirements.txt

flask
redis
1
2

Dockerfile

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["flask", "run"]
1
2
3
4
5
6
7
8
9

docker-compose.yaml

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    networks:
      - app-net

  redis:
    image: "redis:alpine"
    networks:
      - app-net

networks:
  app-net:
    driver: bridge
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

解读 docker-compose.yaml

# 表示 docker-compose 的版本    
version: "3.9"
# 一个 service 表示 container
services:
  web:
    build: .
    # 相当于 -p 5000:5000
    ports:
      - "5000:5000"
    # 相当于-v v1:/var/lib/mysql
    volumes:
      - .:/
    # 相当于-e
    environment:
      FLASK_ENV: development
  redis:
    # 表示使用哪个镜像，本地build则用build，远端则用image
    image: "redis:alpine"
    networks:
      - app-net
# 相当于 docker network create app-net
networks:
  app-net:
    driver: bridge
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#Docker Swarm

(1)环境准备，准备3台Centos机器
    manager：192.168.56.10
    work-node1：192.168.56.11
    work-node2：192.168.56.12
    
(2)进入manager
    docker swarm init --advertise-addr=192.168.56.10
    
    注意观察日志，拿到worker node加入manager node的信息
    docker swarm join --token SWMTKN-1-0a5ph4nehwdm9wzcmlbj2ckqqso38pkd238rprzwcoawabxtdq-arcpra6yzltedpafk3qyvv0y3 192.168.0.10:2377
    
(3)进入两个work-node
    docker swarm join --token SWMTKN-1-0a5ph4nehwdm9wzcmlbj2ckqqso38pkd238rprzwcoawabxtdq-arcpra6yzltedpafk3qyvv0y3 192.168.0.10:2377

(4)进入manger，查看集群状态
    docker node ls

(5)node类型的转换
    可以将worker提升成manager，从而保证manager的高可用
    docker node promote worker-node1
    docker node promote worker-node2
    
    降级可以用demote
    docker node demote worker01-node
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#Swarm基本操作

(1)创建一个tomcat的service
    docker service create --name my-tomcat tomcat
    
(2)查看当前swarm的service
    docker service ls

(3)查看service的启动日志
    docker service logs my-tomcat

(4)查看service的详情
    docker service inspect my-tomcat

(5)查看my-tomcat运行在哪个node上
    docker service ps my-tomcat

(6)水平扩展service，扩展3个
    docker service scale my-tomcat=3
    docker service ls
    docker service ps my-tomcat
    
(7)如果某个node上的my-tomcat挂掉了，这时候会自动扩展

(8)删除service
    docker service rm my-tomcat
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#多机通信overlay网络

workpress+mysql实现个人博客搭建

https://hub.docker.com/_/wordpress?tab=description

传统命令方式

(1)创建mysql容器[创建完成等待一会，注意mysql的版本]
	docker run -d --name mysql -v v1:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=examplepass -e MYSQL_DATABASE=db_wordpress mysql:5.6
	
(2)创建wordpress容器[将wordpress的80端口映射到centos的8080端口]
	docker run -d --name wordpress --link mysql -e WORDPRESS_DB_HOST=mysql:3306 -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=examplepass -e WORDPRESS_DB_NAME=db_wordpress -p 8080:80 wordpress
	
(3)查看默认bridge的网络，可以发现两个容器都在其中
	docker network inspect bridge
	
(4)访问测试
	win浏览器中输入：ip[centos]:8080，一直下一步
1
2
3
4
5
6
7
8
9
10
11

使用docker compose创建

(1)创建wordpress-mysql文件夹
	mkdir -p /tmp/wordpress-mysql
	cd /tmp/wordpress-mysql
	
(2)创建 docker-compose.yml 文件
    vi docker-compose.yml
    
(3)根据 docker-compose.yml 文件创建 service  
    docker-compose up -d
    
(4)访问测试
    win10浏览器ip[centos]:8080，一直下一步

(5)值得关注的点是网络
	docker network ls
	docker network inspect wordpress-mysql_default
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

docker-compose.yml 内容

version: '3.1'

services:

  wordpress:
    image: wordpress
    restart: always
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - wordpress:/var/www/html

  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - db:/var/lib/mysql

volumes:
  wordpress:
  db:
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

#Swarm中实现

(1)创建一个overlay网络，用于docker swarm中多机通信
    [manager-node]
    docker network create -d overlay my-overlay-net
    [此时worker node查看不到]
    docker network ls
    
(2)创建mysql的service
    [manager-node]
    1.创建service
        docker service create --name mysql --mount type=volume,source=v1,destination=/var/lib/mysql --env MYSQL_ROOT_PASSWORD=examplepass --env MYSQL_DATABASE=db_wordpress --network my-overlay-net mysql:5.6
    
    2.查看service
        docker service ls
	    docker service ps mysql

(3)创建wordpress的service
    1.创建service  
    [注意之所以下面可以通过mysql名字访问，也是因为有DNS解析]
        docker service create --name wordpress --env WORDPRESS_DB_USER=root --env WORDPRESS_DB_PASSWORD=examplepass --env WORDPRESS_DB_HOST=mysql:3306 --env WORDPRESS_DB_NAME=db_wordpress -p 8080:80 --network my-overlay-net wordpress
        
    2.查看service
        docker service ls
	    docker service ps mysql

    3.此时mysql和wordpress的service运行在哪个node上
        这时候就能看到my-overlay-net的网络

(4)测试
    win浏览器访问ip[manager/worker01/worker02]:8080都能访问成功
    
(5)查看my-overlay-net 
    docker network inspect my-overlay-net
    
(6)为什么没有用etcd？
    docker swarm中有自己的分布式存储机制
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

#Routing Mesh

#Ingress

通过前面的案例我们发现，部署一个 wordpress 的 service，映射到主机的 8080 端口，这时候通过 swarm 集群中的任意主机 ip:8080 都能成功访问，这是因为什么？

启动命令：

docker service create --name tomcat -p 8080:8080 --network my-overlay-net tomcat

(1)记得使用一个自定义的overlay类型的网络
    --network my-overlay-net
    
(2)查看service情况
    docker service ls
    docker service ps tomcat
    
(3)访问3台机器的ip:8080测试
    发现都能够访问到tomcat的欢迎页
1
2
3
4
5
6
7
8
9
10

#Internal

之前在实战 wordpress+mysql 的时候，发现 wordpress 中可以直接通过 mysql 名称访问。

这样可以说明两点：
第一是其中一定有dns解析，第二是两个service的ip是能够ping通的。

思考：不妨再创建一个service，也同样使用上述tomcat的overlay网络，然后来实验。

(1)启动命令
    docker service create --name whoami -p 8000:8000 --network my-overlay-net -d  jwilder/whoami
    
(2)查看whoami的情况
    docker service ps whoami
    
(3)在各自容器中互相ping一下彼此，也就是容器间的通信
    tomcat容器中ping whoami
        docker exec -it 9d7d4c2b1b80 ping whoami

    whoami容器中ping tomcat
        docker exec -it 5c4fe39e7f60 ping tomcat

(4)将whoami进行扩容
    docker service scale whoami=3
    docker service ps whoami
    
(5)此时再ping whoami service，并且访问whoami服务
    docker exec -it 9d7d4c2b1b80 ping whoami
    [多访问几次，得到的结果不同]
    docker exec -it 9d7d4c2b1b80 curl whoami:8000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

通过上述的实验可以发现什么？

whoami服务对其他服务暴露的ip是不变的，但是通过whoami名称访问8000端口，确实访问到的是不同的service。

也就是说whoami service对其他服务提供了一个统一的VIP入口，别的服务访问时会做负载均衡。

#Stack

docker stack deploy：
https://docs.docker.com/engine/reference/commandline/stack_deploy/

compose-file：
https://docs.docker.com/compose/compose-file/

有没有发现上述部署service很麻烦？
要是能够类似于docker-compose.yml文件那种方式一起管理该多少？
这就要涉及到docker swarm中的Stack，我们直接通过前面的wordpress+mysql案例看看怎么使用咯。
1
2
3
4
5
6
7
8
9 
(1)新建service.yml文件
    vi service.yml

(2)根据service.yml创建service
    docker statck deploy -c service.yml my-service
    
(3)常见操作
    1.查看stack具体信息
        docker stack ls
    2.查看具体的service
        docker stack services my-service
    3.查看某个service
        docker service inspect my-service-db
        
(4)测试访问
    win浏览器ip[manager,worker01,worker02]:8080
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

service.yml

version: '3'

services:

  wordpress:
    image: wordpress
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    networks:
      - ol-net
    volumes:
      - wordpress:/var/www/html
    deploy:
      mode: replicated
      replicas: 3
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
      update_config:
        parallelism: 1
        delay: 10s

  db:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - db:/var/lib/mysql
    networks:
      - ol-net
    deploy:
      mode: global
      placement:
        constraints:
          - node.role == manager

volumes:
  wordpress:
  db:

networks:
  ol-net:
    driver: overlay

标签：compose,service,--,image,命令,mysql,docker
From： https://www.cnblogs.com/gnz48/p/17469561.html

相关文章

  • Linux中cp命令如何使用？其参数有哪些？
    cp是Linux中常用命令之一，该命令主要用于复制文件或目录，那么Linux命令cp如何使用?本文为大家详细介绍一下cp命令，附带使用案例，希望对你有用哦!Linuxcp命令主要用于复制文件或目录。语法：cp[options]sourcedest或cp[options]source...directory参数说明：-a......
  • 使用CNI网络插件(calico)实现docker容器跨主机互联
    目录一.系统环境二.前言三.CNI网络插件简介四.常见的几种CNI网络插件对比五.Calico网络之间是如何通信的六.配置calico让物理机A上的docker容器c1可以访问物理机B上的docker容器c26.1安装部署etcd集群6.2安装部署docker6.3配置calico6.4使用Calico实现Docker容器跨主机互联七.......
  • 使用 cat 及 awk 命令过滤日志文件，求和、求平均值、最大值、最小值
    1、cat查看日志文件$catall.log 2、根据程序打印日志的位置过滤日志条目catall.log|grep-a'ESIndexAggregationTask.java:254' 3、使用awk定位到日志数值位置本轮总计滚动查询2次，总计返回数据62212条，按空格split，62212是11个位置，所以用awk'{pri......
  • 1、Docker介绍、组成、安装、运行容器的核心技术
    Dockerdocker的介绍和基础操作docker单机容器dockercompose单机多个容器k8s多机多个容器container即容器，集装箱docker就是搬运集装的码头工人，管理容器的管理工具Docker的组成Docker主机(Host):一个物理机或虚拟机,用于运行Docker服务进程和容器,也称为宿主机,node节点D......
  • 2、Docker二进制安装脚本
    #!/bin/bashDOCKER_VERSION=20.10.19#URL=https://mirrors.aliyun.comURL=https://download.docker.comprepare(){if[!-edocker-${DOCKER_VERSION}.tgz];then#wget${URL}/docker-ce/linux/static/stable/x86_64/docker-${DOCKER_VERSION}.tgz......
  • 3、Docker镜像管理(下载、删除、打标签、导出导入)
    镜像管理docker镜像是由一层一层的文件系统累积起来的容器的组成最下面：bootfs，引导文件系统，在镜像中不存在，用的是宿主机的内核然后是：rootfs，根文件系统，如centos/ubuntu接着：镜像（jdk）接着：镜像（tomcat）最后：可写容器（container）除了可写层，其他都是只读的。这种情况可以复用，如根文件......
  • 1、Docker二进制安装脚本
    #!/bin/bashDOCKER_VERSION=20.10.19#URL=https://mirrors.aliyun.comURL=https://download.docker.comprepare(){if[!-edocker-${DOCKER_VERSION}.tgz];then#wget${URL}/docker-ce/linux/static/stable/x86_64/docker-${DOCKER_VERSION}.tgz......
  • 修改docker镜像源
    修改docker镜像源原文：https://blog.csdn.net/skh2015java/article/details/82631633方法一：编辑/etc/docker/daemon.jsonvi/etc/docker/daemon.json#添加如下网易镜像源{"registry-mirrors":["http://hub-mirror.c.163.com"]}方法二：编辑/etc/sysconfig/docker......
  • 记录一次 nas docker 运行出错 使用Python脚本检查错误并重启对应容器 npc 运行出
    importosimporttimeimportdatetimeimportsubprocessimportmysql.connector#Docker容器名称container_name="containerName"#MySQL数据库连接配置db_host="localhost"db_user="*********"db_password="*********"db_......
  • docker 安装 es-head 以及Content-Type header请求头错误解决
    拉取es-head镜像,启动dockerpullmobz/elasticsearch-head:5dockerrun-itd--namees-head-p9100:9100mobz/elasticsearch-head:5使用上面的镜像启动会有Content-Typeheader请求头错误的问题,可以进入容器中修改js文件,文章最后有提及,也可编写dockerfile重做镜像,避免......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99