Holding You Back As I Breath You In

文档地址[https://alibaba.github.io/arthas/advanced-use.html]


$ curl -O https://alibaba.github.io/arthas/arthas-boot.jar

#Demo进程是第2个，则输入2，再输入回车/enter。Arthas会attach到目标进程上，并输出日志
$ java -jar arthas-boot.jar
* [1]: 35542
  [2]: 71560 arthas-demo.jar
  
[INFO] Try to attach process 71560
[INFO] Attach process 71560 success.
[INFO] arthas-client connect 127.0.0.1 3658
  ,---.  ,------. ,--------.,--.  ,--.  ,---.   ,---.
 /  O  \ |  .--. ''--.  .--'|  '--'  | /  O  \ '   .-'
|  .-.  ||  '--'.'   |  |   |  .--.  ||  .-.  |`.  `-.
|  | |  ||  |\  \    |  |   |  |  |  ||  | |  |.-'    |
`--' `--'`--' '--'   `--'   `--'  `--'`--' `--'`-----'
 
wiki: https://alibaba.github.io/arthas
version: 3.0.5.20181127201536
pid: 71560
time: 2018-11-28 19:16:24


#当前系统的实时数据面板
$ dashboard  
 
#arthas-demo进程的Main Class 
$ thread 1 | grep 'main('   
    at demo.MathGame.main(MathGame.java:17)

#反编译python
$  jad demo.MathGame  
 
#通过watch命令来查看demo.MathGame#primeFactors函数的返回值 
$ watch demo.MathGame primeFactors returnObj  
 
 
#返回当前的工作目录，和linux命令类似 
$ pwd
 /data/alpha-market/jars
 
#查看当前会话的信息 
$ session
  Name        Value                                                                                                                                                                        
--------------------------------------------------                                                                                                                                        
 JAVA_PID    7276                                                                                                                                                                         
 SESSION_ID  8af7f372-0c5d-4d6a-972b-33840aa6d2fb
 
# 打印命令历史
 $ history
    1  dashboard
    2  dashboard
    3  thread 1 | grep 'main('
    4  jad demo.MathGame
    5  watch demo.MathGame primeFactors returnObj
    6  jvm
 
#关闭 Arthas 服务端，所有 Arthas 客户端全部退出
$ stop
 

#查看当前 JVM 的线程堆栈信息
$ thread
 Threads Total: 90, NEW: 0, RUNNABLE: 21, BLOCKED: 0, WAITING: 44, TIMED_WAITING: 25, TERMINATED: 0                                                                                        
ID              NAME                                          GROUP                          PRIORITY        STATE          %CPU            TIME           INTERRUPTED     DAEMON         
75              Thread-2                                      main                           5               RUNNABLE       29              4:12           false           false          
1511            as-command-execute-daemon                     system                         10              RUNNABLE       20              0:0            false           true           
82              SendDepth-pool-2                              main                           5               RUNNABLE       17              28:22          false           false          
79              Thread-4                                      main                           5               TIMED_WAITING  14              12:20          false           false          
1456            task-56                                       main                           5               TIMED_WAITING  4               0:1            false           false          
1453            task-53                                       main                           5               TIMED_WAITING  3               0:1            false           false          
1454            task-54                                       main                           5               TIMED_WAITING  3               0:1            false           fal
 
#查看当前 JVM 的信息
$ jvm

#通过getstatic命令可以方便的查看类的静态属性
$ getstatic  com.alpha.market.service.impl.QueryServiceImpl logger

[容器]
 $ docker run -ite --name runoob  ubuntu:15.10  //-t: 在新容器内指定一个伪终端或终端。  -i: 允许你对容器内的标准输入 (STDIN) 进行交互。 --name 标识来命名容器,配置名称来与虚拟ip做映射  d 后台运行容器
							  
 $ docker pull ubuntu                           //获取镜像
                                                
 $ docker ps -a                                 //查看所有的容器命令
                                                
 $ docker start   <容器 ID>                     //使用 docker start 启动一个已停止的容器：
                                                
 $ docker stop    <容器 ID>                     //停止容器的命令
                                                
 $ docker restart <容器 ID>                     //重启容器的命令
                                                
 $ docker exec    <容器 ID>                     //在使用 -d 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令 ex：docker exec -it 243c32535da7 /bin/bash
                                                
 $ docker rm -f   <容器 ID>                     //删除容器使用 docker rm 命令 
                                                
 $ docker port    <容器 ID>                     //可以查看指定(ID 或者名字)容器的某个确定端口映射到宿主机的端口号
                                                
 $ docker logs -f <容器 ID>                     //可以查看容器内部的标准输出。 docker logs 像使用 tail -f 一样来输出容器内部的标准输出。
                                                
 $ docker top     <容器 ID>                     //查看容器内部运行的进程
                                                
 $ docker inspect <容器 ID>                     //查看 Docker 的底层信息
 
[镜像]
  
 $ docker images                                //本地主机上的镜像
                                                
 $ docker search httpd                          //查找镜像 
                                                
 $ docker pull ubuntu:13.10                     //拖取镜像
                                                
 $ docker rmi hello-world                       //删除镜像
                                                
 $ docker build -t runoob/centos:6.7 .          //-t ：指定要创建的目标镜像名 .表示 Dockerfile 文件所在目录，可以指定Dockerfile 的绝对路径
 
 $ docker tag 860c279d2fec runoob/centos:dev，  //  为镜像添加一个新的标签
 

[容器链接]

 $  docker run -d -p 5000:5000 training/webapp python app.py          //网络端口映射   -P :是容器内部端口随机映射到主机的高端口。-p : 是容器内部端口绑定到指定的主机端口。
                                                                      
 $  docker network create -d bridge test-net                          //创建一个新的 Docker 网络  -d 参数指定 Docker 网络类型，有 bridge、overlay
 
 $  docker run -itd --name test1 --network test-net ubuntu /bin/bash  //运行一个容器并连接到新建的 test-net 网络
 
 $  docker run -itd --name test2 --network test-net ubuntu /bin/bash  //运行一个容器并连接到新建的 test-net 网络
 
[单向通信] (容器创建完成后都会生成一个唯一的ip，这个ip外界不能直接访问，他只用于容器之间进行通信交互用。这就是虚拟ip 容器之间的虚拟ip是互通的)
                               
 $ docker run -d --name mytomcat tomcat                              //创建tomcat容器 --name就是给docker配置名称来与虚拟ip做映射
                                                                     
 $ docker run -d --name database -it mysql /bin/bash                 //创建mysql容器
                                                                     
 $ docker inspect <容器 ID>                                          //容器的虚拟ip怎么查 进入mytomcat的容器然后去ping database的ip看看是否通
 
 $ docker exec -it mytomcat /bin/bash                
   ping 172.17.0.6
 
[单向通信使用容器昵称] 
 
 $ docker rm -f mytomcat                                             //强制删除老的
                                                                     
 $ docker run -d --name mytomcat --link database tomcat              //创建新的容器，用--link指定我们想连的配置的数据库“域名”
                                                                     
 $ docker exec -it mytomcat /bin/bash                                //进入mytomcat容器
  
 $ ping database

[双向通信]

  暂无
  
  
[容器间数据共享]

 $ docker run -v /home/main/programe:/usr/local/tomcat/webapps tomcat   //比如如下：他会把/home/main/programe下面的所有目录都挂载到容器的/usr/local/tomcat/webapps下

[共享容器概念]

 
 $ docker create --name <共享容器名称> -v <宿主机路径>:<容器内挂载路径> 镜像名称 /bin/true 
 
 $ docker run --volumes-from <共享容器名称> --name xxx -d <镜像名称> 
 
 $ docker create --name webpage -v /home/docker:/usr/local/ tomcat /bin/true //创建共享容器
 
 $ docker run -p 8300:8080 --volumes-from webpage --name t3 -d tomcat //采取共享容器的配置来启动容器
 
 $ docker run -p 8400:8080 --volumes-from webpage --name t4 -d tomcat
 

[DockerCompose] 
  
 
 
 
 
[Docker File ]

  1.FROM:定制的镜像都是基于 FROM 的镜像，这里的 nginx 就是定制需要的基础镜像。后续的操作都是基于 nginx。
  
  2.RUN:用于执行后面跟着的命令行命令。构建镜像时运行,有以下俩种格式：
  
     Shell 格式：
     RUN <命令行命令>
     # <命令行命令> 等同于，在终端操作的 shell 命令

     exec 格式：
     RUN ["可执行文件", "参数1", "参数2"]
     # 例如：
     # RUN ["./test.php", "dev", "offline"] 等价于 RUN ./test.php dev offline  
	 
  3.COPY:复制指令，从上下文目录中复制文件或者目录到容器里指定路径
  
  4.ADD: ADD 的优点：在执行 <源文件> 为 tar 压缩文件的话，压缩格式为 gzip, bzip2 以及 xz 的情况下，会自动复制并解压到 <目标路径> 
         ADD 的缺点：在不解压的前提下，无法复制 tar 压缩文件。会令镜像构建缓存失效
 
  5.CMD:类似于 RUN 指令，用于运行程序，但二者运行的时间点不同:
  
           1.CMD 在docker run 时运行。RUN 是在 docker build。为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束
		   2.CMD 指令指定的程序可被 docker run命令行参数中指定要运行的程序所覆盖,即如果容器启动的时候有其他额外的附加指令，则CMD指令不生效
		   3.如果 Dockerfile 中如果存在多个 CMD 指令，仅最后一个生效
  
  6.ENTRYPOINT:类似于 CMD 指令，但其不会被 docker run 的命令行参数指定的指令所覆盖，而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。
     说明：ENTRYPOINT和CMD可以共用，若共用则他会一起合并执行
           ENTRYPOINT ["ps"]
           CMD ["-ef"]
		   他给我们合并执行了：ps -ef，这么做的好处在于如果容器启动的时候添加额外指令，CMD会失效，可以理解成我们可以动态的改变CMD内容而不需要重新构建镜像等操作。比如
		   docker run chentongwei.com/docker-run -aux
		   结果直接变成了 ps -aux
  
  7.ENV:设置环境变量，定义了环境变量，那么在后续的指令中，就可以使用这个环境变量,${xxx}来引用
  
  8.ARG:构建参数，与 ENV 作用一至。不过作用域不一样。ARG 设置的环境变量仅对 Dockerfile 内有效，也就是说只有 docker build 的过程中有效，构建好的镜像内不存在此环境变量。
  
  9.VOLUME:定义匿名数据卷。在启动容器时忘记挂载数据卷，会自动挂载到匿名卷。避免重要的数据，因容器重启而丢失，这是非常致命的
  
 10.EXPOSE:声明端口,帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射,在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。
  
 11.WORKDIR:指定工作目录。用 WORKDIR 指定的工作目录，会在构建镜像的每一层中都存在。（WORKDIR 指定的工作目录，必须是提前创建好的）。docker build 构建镜像过程中的，
    每一个 RUN 命令都是新建的一层。只有通过 WORKDIR 创建的目录才会一直存在。
	
 12.USER:用于指定执行后续命令的用户和用户组，这边只是切换后续命令执行的用户（用户和用户组必须提前已经存在）。
 
 13.HEALTHCHECK:用于指定某个程序或者指令来监控 docker 容器服务的运行状态

 14.ONBUILD:用于延迟构建命令的执行。简单的说，就是 Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。
    当有新的 Dockerfile 使用了之前构建的镜像 FROM test-build ，这是执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令。
 15.MAINTAINER:一般写个人id或组织id
 16.LABEL:就是注释，方便阅读的，纯注释说明
 17.
  
  
[Docker Redis ](开启Redis(修改Redis.conf daemonize为no))
   
 $ docker run -itd --name redis-demo  -p:6378:6378 -v /usr/redis-5.0.8/redis.conf:/etc/redis/redis.conf  -v /usr/redis-5.0.8/data:/data -d redis redis-server /etc/redis/redis.conf
 
 $ docker exec -it <容器 ID> /bin/bash                                                 //进入容器
                                                                                       
 $ docker commit -m="has update" -a="runoob" e218edb10161 runoob/ubuntu:v2             //打包提交为新容器 -m: 提交的描述信息 -a: 指定镜像作者 e218edb10161：容器 ID runoob/ubuntu:v2: 指定要创建的目标镜像名 
                                                                                       
 $ docker run -itd runoob/ubuntu:v2 /bin/bash                                          //使用我们的新镜像 runoob/ubuntu 来启动一个容器 使用新镜像(docker images 命令来查看我们的新镜像runoob/ubuntu:v2)
  
  
[Docker Mysql ] 

 $ docker search mysql                                                                 //查询镜像                                                                
                                                                                       
 $ docker pull mysql                                                                   //拉取镜像                                                            
 
 $ docker run -itd --name mysql-test -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql  //设置 MySQL 服务 root 用户的密码
 
 $ docker exec -it <容器 ID> /bin/bash                                                 //进入镜像                                              
                                                                                       
 $ mysql -h localhost  -u root -p                                                      //登录mysql
                                                                                       
 $ ALTER USER 'root'@'%' IDENTIFIED BY '123456';                                       //修改Root 不能远程登录

 $ CREATE USER 'liaozesong'@'%' IDENTIFIED WITH mysql_native_password BY 'Lzslov123!'; //添加远程登录用户
 
 $ GRANT ALL PRIVILEGES ON *.* TO 'liaozesong'@'%';                                    //给用户所有权限


[Docker Mongo] 
 
 $ docker search mongo                                                                  //查询镜像     
 
 $ docker pull mongo:latest                                                             //拉取镜像      
 
 $ docker run -itd --name mongo -p 27017:27017 mongo --auth                             //运行容器      
 
 $ docker exec -it mongo mongo admin                                                    //进入容器     

 $ db.createUser({ user:'admin',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'}]});  //创建一个名为 admin，密码为 123456 的用户。 
 
 $ db.auth('admin', '123456')

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 

提示:

  Dockerfile 的指令每执行一次都会在 docker 上新建一层。所以过多无意义的层，会造成镜像膨胀过大 以 && 符号连接命令，这样执行后，只会创建 1 层镜像]  

FROM centos
RUN yum install wget
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
RUN tar -xvf redis.tar.gz
以上执行会创建 3 层镜像。可简化为以下格式：
FROM centos
RUN yum install wget \
    && wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \
    && tar -xvf redis.tar.gz

1.CAP 理论可以表述为，一个分布式系统最多只能同时满足两者。并且P是确定的
    一致性（Consistency）所有节点同时看到相同的数据
    可用性（Availability）任何时候，读写都是成功的
    分区容忍性（Partition Tolerance）当部分节点出现消息丢失或者分区故障的时候，分布式系统仍然能够继续运行
 ex:P 分布式  C 强一致性就不能保证A,比如 由于节点存在故障所以一致性不能保证。

 [ Base]
      Base理论的核心思想是最终一致性，Base 理论则是对 CAP 理论的实际应用,即使无法做到强一致性（StrongConsistency），
  但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性（Eventual Consistency）。 
  三要素：
     1.基本可用(允许损失部分可用性,相比正常的系统，可能是响应时间延长，或者是服务被降级)
	   ex:举个例子，在双十一秒杀活动中，如果抢购人数太多超过了系统的 QPS 峰值，可能会排队或者提示限流，这就是通过合理的手段保护系统的稳定性，保证主要的服务正常，保证基本可用
	 2.软状态(允许系统中的数据存在中间状态，并认为该状态不影响系统的整体可用性，即允许系统在多个不同节点的数据副本存在数据延时)
	 3.最终一致性(在一个时间期限之后达到各个节点的一致性，在期限过后，应当保证所有副本保持数据一致性，也就是达到数据的最终一致性)
	 
	不同数据一致性模型:
     1.强一致性:当更新操作完成之后，任何多个后续进程的访问都会返回最新的更新过的值,需要牺牲可用性
     2.弱一致性:在数据写入成功之后，不承诺立即可以读到最新写入的值
     3.最终一致性:需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性
	        1.因果一致性:因果关系的操作顺序得到保证，非因果关系的操作顺序则无所谓
			2.会话一致性:你的一次访问中，执行更新操作之后，客户端能够在同一个会话中始终读取到该数据项的最新值
			
[ACID] 是一种强一致性模型，强调原子性、一致性、隔离性和持久性，主要用于在数据库实现中,适合传统金融等业务