文档章节

docker的使用及原理

AllenOR灵感
 AllenOR灵感
发布于 2017/09/10 01:11
字数 4690
阅读 18
收藏 0

引子

如何在内网搭一个私人笔记

一步步搭建Leanote笔记

使用docker

什么是docker

下面是从wikipedia和百度百科摘下来描述docker的文字:

wikipedia

Docker is an open-source project that automates the deployment of applications inside software containers, by providing an additional layer of abstraction and automation of operating-system-level virtualization on Linux.

Docker implements a high-level API to provide lightweight containers that run processes in isolation.

百度百科

Docker 是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的 Linux 机器上,也可以实现虚拟化。容器是完全使用沙箱机制,相互之间不会有任何接口(类似 iPhone 的 app)。几乎没有性能开销,可以很容易地在机器和数据中心中运行。

docker的特点

资源占用少

启动快

几乎没有性能损耗

镜像脚本化构建

快速交付应用程序,隐藏内部细节

...

docker的使用

概念

Docker几个概念的生命周期


镜像

docker镜像从概念上讲类似于vm里面的iso文件,就是一个只读的模板。一个镜像可以包含一个Linux操作系统,里面安装了一系列的软件。镜像可以拷到任何装了docker的机器上运行。

仓库

存储docker镜像的地方就是镜像仓库, 全球最大的docker镜像仓库是docker.io, 里面有大量官方和民间的优秀镜像可以直接拿过来使用,如mysql, centos等等。阿里也有自己的docker仓库: docker.alibaba-inc.com

容器

容器与镜像的关系有点像进程与程序的关系,运行中的镜像就叫容器。 从原理上讲,容器事实上是镜像上面加了一层读写层,以及一个被隔离的进程空间。 后面原理部分会具体介绍。

常用命令

以下简单整理了一些docker最常用的命令,详细的命令请参考相关手册。 (其中bansheng_hawkeye_web是为这篇文章临时做的一个镜像)

获取镜像

docker pull $image_name

举例:dockerpullcentos:lastest从index.io获取最新的centos系统镜像到本地,:lastest可以不写,为默认版本。

运行镜像

交互式地运行镜像

dockerrun-t -i$image_name[$cmd]如果$image_name本地不存在,docker会先自动从远程仓库pull镜像。-t表示在新容器内指定一个伪终端或终端,-i表示允许我们对容器内的STDIN进行交互。 $cmd为需要运行的程序。举例:1. dockerrun-t -i  centos:lastest  /bin/bash

后台运行镜像

dockerrun-d$image_name[$cmd]与交互式的运行镜像不同的是,-d参数表示daemon,即运行守护进程。 可以通过后面介绍的attach和exec命令来操作已经运行的docker容器。举例:1. dockerrun-dcentos:lastest  sleep 1000000我们也可以不指定$cmd命令,这时会调用镜像制作时Dockerfile文件中指定的程序,后面会介绍。

操作运行中的容器

docker attach$container_id$container_id可以通过docker ps-a命令看到。    attach到$container后,就相当于打开了一个终端,以及与STDIN进行交互。    这个命令一般用来查看容器的输出logdockerexec-t -i$container_id$cmd通过这个命令可以执行一个运行中的容器中的任何命令,并打开与STDIN的交互。    如: dockerexec-t -i$container_id/bin/bash

给容器取名字

dockerrun--name 容器名 ...默认情况下,docker会给容器自动取一个独一无二的名字,可以通过docker ps -a看到,docker会保证容器名是唯一的。 当然我们也可以通过--name具体指定一个名字。docker attach和exec之类的命令中即可以使用$container_id关联容器,也可以直接通过容器名关联容器,这样更人性化一些。

端口映射

dockerrun-d-P(大写)$image_name[$cmd]docker可以通过Dockerfile在制作镜像时暴露一些端口出来,如web的80端口。 那么就需要在宿主机中指定一个端口映射到容器中的端口。    使用-P参数让容器启动时自动分配宿主机的端口到容器的端口。    举例(gogs是一个go语言实现的git服务,带web):    dockerrun-d--name=gogs  data:/data -P songlijun/gogs运行后使用docker port查看docker自动分配的端口,如:    docker port $contaniner_id22/tcp ->0.0.0.0:321233000/tcp ->0.0.0.0:34222那么在浏览器访问: http://宿主机IP:34222即可访问hawkeye_web页面。dockerrun-d-p(小写) 主机端口:容器暴露的端口$image_name[$cmd]与-P类似,小写的-p可以显示指定主机端口,如:    dockerrun-d--name=gogs  -p 10080:3000 -p 22222:22 songlijun/gogsdocker port $contaniner_id22/tcp ->0.0.0.0:222223000/tcp ->0.0.0.0:10080

文件映射

dockerrun-d-v 主机目录:容器目录$image_name[$cmd]容器中产生的文件随着容器被删除也会被删除,这时有两种方法来持久化数据:1. 容器删除前做一次commit,将容器的最新状态及数据做成一个镜像,然后更新到镜像仓库。2. 使用这里说的文件映射,将主机中的一个目录映射到容器中,这种方法有很多使用场景,如在宿主机上看到容器的log文件,或者将mysql的data数据关联到宿主机的某个目录下,这样即使是容器被删,数据还是保留着的。举例(注意-v的两个目录都需要为绝对路径):dockerrun-d--name=gogs -v /root/gogs_data:/data -p 10080:3000 -p 22222:22 songlijun/gogs

环境变量

dockerrun-eVAR_1=xxx-eVAR_2=yyy$image_name[$cmd]-e后面可以指定一些环境变量值,在容器运行的时候可以读到这些变量,容器的启动脚本可以使用这些变量做一些宏替换等操作,达到读取启动参数的目的。

容器连接

容器1: dockerrun--name container_1_name ...容器2:  dockerrun--link container_1_name:container_1_name_in_container2 ...这样容器2就可以读到容器1的所有环境变量, 以及一些暴露出去的端口信息等。 这种连接方式有效的避免了将一些变量暴露到这两个容器之外。举例:官方的phpmyadmin镜像与mysql数据库就使用这种方式进行关联:dockerrun--name mysql-eMYSQL_ROOT_PASSWORD=my_password-dmysqldockerrun--link mysql:mysql -p 1234:80 nazarpc/phpmyadmin

制作镜像

从运行中的容器制作镜像

docker commit $container_id $image_name即将一个容器(运行中或者Exit状态都可以) 做一次commit, 就可以做成一个本地镜像, $image_name是取的新镜像名。注:这种方式做镜像比较方便,但是项目的其它成员就不太清楚这个镜像的具体生成细节,不易维护。

使用Dockerfile

docker build -t$image_name-f dockerfileDockerfile是一种脚本化描述生成镜像过程的方法,将镜像的生成指令写到文件中,便于分享给其它人,具体语法不展开说,参见官方文档: https://docs.docker.com/engine/reference/builder/

提交镜像

dockerpush$image_name提交名为$image_name的镜像, 镜像名中包含了镜像仓库的地址,默认为docker.io如:dockerpushsonglijun/proxy-client

docker的原理

技术点比较多,这里挑一些简单的介绍下,更多的知识点参考文末的外部资料链接。

Linux Namespace

docker是一个容器引擎,容器就要求对进程空间、用户空间、网络空间、硬盘空间等等做一些隔离,docker的底层是使用LXC实现的,LXC则使用Linux Namespace技术对各种技术做隔离。

Linux Namespace是Linux提供的一种内核级别环境隔离的方法, 隔离的资源包括:Mount、UTS、IPC、PID、Network、User。 篇幅限制,本文只介绍UTS、PID和Mount的隔离。

网上找来一段代码:

#define_GNU_SOURCE#include#include#include#include#include#include#include/* 定义一个给 clone 用的栈,栈大小1M */#defineSTACK_SIZE (1024 * 1024)staticcharcontainer_stack[STACK_SIZE];char*constcontainer_args[] = {"/bin/bash",NULL};intcontainer_main(void* arg){printf("Container - inside the container!\n");/* 直接执行一个shell,以便我们观察这个进程空间里的资源是否被隔离了 */execv(container_args[0], container_args);printf("Something's wrong!\n");return1;}intmain(){printf("Parent - start a container!\n");/* 调用clone函数,其中传出一个函数,还有一个栈空间的(为什么传尾指针,因为栈是反着的) */intcontainer_pid = clone(container_main, container_stack+STACK_SIZE, SIGCHLD,NULL);if(container_pid <0)    {fprintf(stderr,"clone failed WTF!!!! %s\n", strerror(errno));return-1;    }/* 等待子进程结束 */waitpid(container_pid,NULL,0);printf("Parent - container stopped!\n");return0;}

代码比较简单,就是用clone系统调用生成一个新的子进程,并运行container_main函数。

运行结果:

[lijun.slj@e100081001115.zmf /home/lijun.slj/hawkeye_web_docker/samples]$./simple_clone Parent - start a container!Container - inside the container![lijun.slj@e100081001115.zmf /home/lijun.slj/hawkeye_web_docker/samples]$ps aux |headUSER      PID %CPU %MEM    VSZ  RSS TTY      STAT START  TIME COMMANDroot10.0  0.0413763520?        Ss  10:25  0:07 /usr/lib/systemd/systemd --switched-root --system --deserialize 21root20.0  0.000?        S    10:25  0:00 [kthreadd]root30.0  0.000?        S    10:25  0:02 [ksoftirqd/0]root60.0  0.000?        S    10:25  0:16 [kworker/u30:0]root70.0  0.000?        S    10:25  0:01 [migration/0]root80.0  0.000?        S    10:25  0:00 [rcu_bh]root90.0  0.000?        S    10:25  0:00 [rcuob/0]root100.0  0.000?        S    10:25  0:00 [rcuob/1]root110.0  0.000?        S    10:25  0:00 [rcuob/2]

可以看到,在进入了子进程后看到的跟父进程完全一样。

我们往上段代码的clone函数中加入CLONE_NEWUTS flag, 并且在container_main函数中设置主机名:

#define_GNU_SOURCE#include#include#include#include#include/* 定义一个给 clone 用的栈,栈大小1M */#defineSTACK_SIZE (1024 * 1024)staticcharcontainer_stack[STACK_SIZE];char*constcontainer_args[] = {"/bin/bash",NULL};intcontainer_main(void* arg){printf("Container - inside the container!\n");    sethostname("container",10);/* 设置hostname *//* 直接执行一个shell,以便我们观察这个进程空间里的资源是否被隔离了 */execv(container_args[0], container_args);printf("Something's wrong!\n");return1;}intmain(){printf("Parent - start a container!\n");/* 调用clone函数,其中传出一个函数,还有一个栈空间的(为什么传尾指针,因为栈是反着的) */intcontainer_pid = clone(container_main, container_stack+STACK_SIZE,            CLONE_NEWUTS | SIGCHLD,NULL);/*启用CLONE_NEWUTS Namespace隔离 */if(container_pid <0)    {printf("%d clone failed WTF!!!! %s\n", container_pid, strerror(errno));return-1;    }/* 等待子进程结束 */waitpid(container_pid,NULL,0);printf("Parent - container stopped!\n");return0;}

运行:

[lijun.slj@e010125011037.bja /home/lijun.slj/hawkeye_web_docker/samples]$sudo ./utsParent -startacontainer!Container- inside thecontainer![root@container/home/lijun.slj/hawkeye_web_docker/samples]#hostnamecontainer[root@container/home/lijun.slj/hawkeye_web_docker/samples]#exitexitParent-containerstopped![lijun.slj@e010125011037.bja /home/lijun.slj/hawkeye_web_docker/samples]$

可以看到子进程中的hostname变成了container

我们接着在clone函数中加入CLONE_NEWPID flag, 并在主子进程中都打出pid:

#define_GNU_SOURCE#include#include#include#include#include#include#include/* 定义一个给 clone 用的栈,栈大小1M */#defineSTACK_SIZE (1024 * 1024)staticcharcontainer_stack[STACK_SIZE];char*constcontainer_args[] = {"/bin/bash",NULL};intcontainer_main(void* arg){printf("Container [%5d] - inside the container!\n", getpid());    sethostname("container",10);/* 设置hostname *//* 直接执行一个shell,以便我们观察这个进程空间里的资源是否被隔离了 */execv(container_args[0], container_args);printf("Something's wrong!\n");return1;}intmain(){printf("Parent [%5d] - start a container!\n", getpid());/* 调用clone函数,其中传出一个函数,还有一个栈空间的(为什么传尾指针,因为栈是反着的) */intcontainer_pid = clone(container_main, container_stack+STACK_SIZE,            CLONE_NEWUTS | CLONE_NEWPID | SIGCHLD,NULL);/*启用CLONE_NEWUTS Namespace隔离 */if(container_pid <0)    {printf("%d clone failed WTF!!!! %s\n", container_pid, strerror(errno));return-1;    }/* 等待子进程结束 */waitpid(container_pid,NULL,0);printf("Parent - container stopped!\n");return0;}

运行:

[lijun.slj@e010125011037.bja /home/lijun.slj/hawkeye_web_docker/samples]$sudo ./pidParent [17121] - start a container!Container [    1] - inside the container![root@container /home/lijun.slj/hawkeye_web_docker/samples]#ps aux |headUSER      PID %CPU %MEM    VSZ  RSS TTY      STAT START  TIME COMMANDroot10.0  0.0413763520?        Ss  10:25  0:07 /usr/lib/systemd/systemd --switched-root --system --deserialize 21root20.0  0.000?        S    10:25  0:00 [kthreadd]root30.0  0.000?        S    10:25  0:02 [ksoftirqd/0]root60.0  0.000?        S    10:25  0:16 [kworker/u30:0]root70.0  0.000?        S    10:25  0:01 [migration/0]root80.0  0.000?        S    10:25  0:00 [rcu_bh]root90.0  0.000?        S    10:25  0:00 [rcuob/0]root100.0  0.000?        S    10:25  0:00 [rcuob/1]root110.0  0.000?        S    10:25  0:00 [rcuob/2][root@container /home/lijun.slj/hawkeye_web_docker/samples]#

可以看到子进程的pid变成了1。 这个变化很重要,意味着子进程后面的所有进程,都是挂在这个PID为1的进程后面。看起来就像是一个新的系统,而该子进程就像是pid为1的init进程。

但是上面的ps结果也看到,子进程仍然可以看以父进程的所有进程,原因是主子进程中的ps命令都是去读的/proc文件系统,我们需要对子进程单独mount一个proc文件系统出来。

接着改代码,给clone函数加一个CLONE_NEWNS flag, 并在子进程中运行 mount -t /proc proc /proc命令:

#define_GNU_SOURCE#include#include#include#include#include#include#include/* 定义一个给 clone 用的栈,栈大小1M */#defineSTACK_SIZE (1024 * 1024)staticcharcontainer_stack[STACK_SIZE];char*constcontainer_args[] = {"/bin/bash",NULL};intcontainer_main(void* arg){printf("Container [%5d] - inside the container!\n", getpid());    sethostname("container",10);/* 设置hostname *//* 重新mount proc文件系统到 /proc下 */system("mount -t proc proc /proc");/* 直接执行一个shell,以便我们观察这个进程空间里的资源是否被隔离了 */execv(container_args[0], container_args);printf("Something's wrong!\n");return1;}intmain(){printf("Parent [%5d] - start a container!\n", getpid());/* 调用clone函数,其中传出一个函数,还有一个栈空间的(为什么传尾指针,因为栈是反着的) */intcontainer_pid = clone(container_main, container_stack+STACK_SIZE,            CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWNS | SIGCHLD,NULL);/*启用CLONE_NEWUTS Namespace隔离 */if(container_pid <0)    {printf("%d clone failed WTF!!!! %s\n", container_pid, strerror(errno));return-1;    }/* 等待子进程结束 */waitpid(container_pid,NULL,0);printf("Parent - container stopped!\n");return0;}

运行:

[lijun.slj@e010125011037.bja /home/lijun.slj/hawkeye_web_docker/samples]$sudo ./mountParent [18594] -startacontainer!Container[1] - inside thecontainer![root@container/home/lijun.slj/hawkeye_web_docker/samples]#ps auxUSERPID %CPU %MEM    VSZ  RSS TTY      STATSTARTTIMECOMMANDroot11.30.01167043276pts/0S22:550:00/bin/bashroot300.00.01394921632pts/0R+22:560:00ps aux[root@container/home/lijun.slj/hawkeye_web_docker/samples]#

可以看到,ps也只能看到子进程中的进程了。

这个时候还可以看一下,父进程实际上可以看到子进程的进程,并且pid不为1,而子进程就像一只井底之蛙,只能看到自己被隔离出来的进程。

[lijun.slj@e010125011037.bja /home/lijun.slj/localha3_docker]$ps aux |grep /bin/bashroot203230.0  0.01167043284pts/0    S+  23:00  0:00 /bin/bashlijun.s+207890.0  0.0112644956pts/3    S+  23:02  0:00 grep --color=auto /bin/bash

AUFS文件系统

docker使用的文件系统有aufs、devicemapper等,aufs是docker的首选文件系统,但是可惜没有合到Linux主干代码中,不过主流的系统像ubuntu都是支持的。 而像centos这种系统不支持aufs, 就只能使用devicemapper了。

由于aufs对理解docker的layer(层)的概念更容易一些,这里介绍下aufs文件系统。

闲话不多说,找个ubuntu 12.04版本的系统做如下测试:

建两个目录d1,d2 d1中有文件a和b, d2中有文件b和c:

root@vultr:~/test_aufs/test1# ls -Rd1 d2./d1:a  b./d2:b  c

其中每个文件的值为: d1/a -> 'a', d1/b -> 'b1', d2/b -> 'b2', d2/c -> 'c'

用d1, d2 mount一个aufs文件系统的目录:

root@vultr:~/test_aufs/test1# mount -t aufs -o dirs=./d1:./d2 none ./mntroot@vultr:~/test_aufs/test1# ls mnt/a  b  croot@vultr:~/test_aufs/test1# cat mnt/bb1

可以看到mnt/b中的值为d1/b中的值,而d2/b被丢掉了。 可见mnt多个目录同一个文件名的文件,只保留按顺序第一次出现的那个。

再尝试着更改文件内容:

root@vultr:~/test_aufs/test1/mnt# echo 'new_a' > aroot@vultr:~/test_aufs/test1/mnt# cat ../d1/anew_aroot@vultr:~/test_aufs/test1/mnt# echo 'new_b' > broot@vultr:~/test_aufs/test1/mnt# cat ../d1/bnew_broot@vultr:~/test_aufs/test1/mnt# cat ../d2/bb2root@vultr:~/test_aufs/test1/mnt# echo 'new_c' > croot@vultr:~/test_aufs/test1/mnt# cat ../d2/ccroot@vultr:~/test_aufs/test1/mnt# cat ../d1/cnew_croot@vultr:~/test_aufs/test1/mnt#

前几个都好理解,注意往mnt/c中写一段内容后,d2/c的内容并没有改变,反而在d1目录下面出现了一个c,内容为mnt/c的内容,好诡异,这是什么逻辑呢。

原来mount aufs文件系统的目录时,最前面的目录是可写的,而后面的都是只读的,往mnt下面的文件写内容时,会先找到第一个可写的目录,然后更新其内容, 如果文件不存在则会建一个。 d2/c被mnt成只读的了不会改变内容,而且d1目录是可写的,所以会在d1下面新生成一个c文件。

我们还可以试着mount aufs时在目录后面加上:rw, :ro来表示读写和只读,会有不同的结果,但是原理与上段描述的一样,可以猜猜结果会是怎样。

不知道大家有没有用过Ubuntu或Fedora的live系统盘,只要插上光盘就可以运行系统,而且还可以写数据,只不过系统退出后变更的文件就找不到了。当时觉得很神奇,现在想想也正是使用了aufs这种文件系统的特性,只要将光盘和硬盘mount在一起,就可以看上去在光盘上读写数据了。

回到docker,docker的镜像其实就是一些只读层,而容器是在docker镜像上加了一层读写层,这样就可以在不更改镜像的基础上还能像普通vm一样读写数据。 网上有张图比较好:


重新理解Docker的各种命令

我们了解了docker的文件系统及namespace功能后,再试图重新理解一下docker的几个命令:

docker images : 列出所有顶层的只读镜像

docker run : 先是利用只读的镜像外加一层可读写的层,并且加了一个被隔离的进程空间来创建了一个容器,然后运行指定的程序。

docker stop : 保留可读写层,收回隔离的进程空间。

docker ps -a : 列出所有包含读写层的容器,包含stop(Exit)状态的。

docker commit : 将当前容器的只读层加可读写层一起产生一个新的只读层做为镜像。

几个例子

HawkeyeWeb

docker run --name hawkeye_web_test -d -p主机http端口:80reg.docker.alibaba-inc.com/bansheng_hawkeye-web运行后浏览器访问:  http://主机ip:给定的主机http端口 即可访问此镜像默认使用hawkeye_web对应的idb线下数据库,可以指定MYSQL_IP,MYSQL_PORT,MYSQL_DBNAME,MYSQL_USER,MYSQL_PASSWORD几个环境变量来连接特定的线下数据库,方便线下开发测试。

代理服务

PS: 能看到最后的都是好汉, 分享点好东西犒劳下...

做了两个镜像(songlijun/proxy-client, songlijun/proxy-server)用于翻墙,使用很久了比较稳定,有兴趣可以参考README:http://gitlab.alibaba-inc.com/lijun.slj/docker/tree/master/proxy-clienthttp://gitlab.alibaba-inc.com/lijun.slj/docker/tree/master/proxy-server镜像在国内的仓库也有备份, pull速度要快一些:index.alauda.cn/songlijun/proxy-clientindex.alauda.cn/songlijun/proxy-server

经典游戏

docker run -i-t -p80:80index.alauda.cn/dubuqingfeng/docker-web-game提供了超级玛丽,坦克大战,吃豆人三个经典游戏~

LocalHa3

本打算做一个集成的localha3 docker,但是遇到些感觉是alios5u7镜像bug的问题,没来得及做完。半成品见:http://gitlab.alibaba-inc.com/lijun.slj/localha3_docker/tree/master设计上该docker应该可以用文件映射来接收build的xml数据,并配合一个简易的web系统来控制build及重启,以及往本机curl一个query的功能。

引用

10张图带你深入理解Docker容器和镜像

Docker基础技术:Linux Namespace(上)

Docker基础技术:Linux Namespace(下)

Docker基础技术:AUFS

Docker基础技术:DeviceMapper

Docker 中文教程

非常详细的 Docker 学习笔记

本文转载自:http://www.jianshu.com/p/0b00e2c4a76f

AllenOR灵感
粉丝 11
博文 2635
码字总数 83001
作品 0
程序员
私信 提问
广州站|一场36小时的集中脑爆式Docker培训课程

Docker是基于Go语言实现的云开源项目,诞生于2013年初,最初发起者是dotCloud公司。Docker自开源后就受到广泛的关注和讨论,目前已有多个相关项目,逐渐形成了围绕Docker的生态体系。dotClou...

DockOne
2016/11/10
35
0
3 天烧脑式容器存储网络训练营 | 深圳站

容器进入云计算AI时代,大规模容器集群即将进入千万家企业,业务特征十分复杂,如:容器数量庞大,需要满足快速部署灵活迁移,保证容器间跨物理机间的通信;保证业务、资源与物理位置无关,容...

DockOne
2017/07/06
316
0
Java Spring Boot 2.0实战Docker容器与架构原理,视频与课件,基于Linux环境

Java Spring Boot 2.0实战Docker容器Linux与架构原理 内容摘要:Docker是最流行的开源容器引擎,Go语言开发,在互联网大规模集群、云计算、微服务等架构中广泛使用。本次课程一起学习Docker容...

徐雷frank
02/27
0
0
3 天烧脑式容器存储网络训练营 | 深圳站

容器进入云计算AI时代,大规模容器集群即将进入千万家企业,业务特征十分复杂,如:容器数量庞大,需要满足快速部署灵活迁移,保证容器间跨物理机间的通信;保证业务、资源与物理位置无关,容...

DockOne
2017/07/06
70
0
Docker容器运行GUI程序的配置方法

0.环境说明 Ubuntu 16.04 docker 1.35 1.Docker的“可视化” Docker本身的工作模式是命令行的,因为主要的使用场景可能是做服务器后端方面的比较多。 但有时候我们会有在docker容器里运行一些...

李金泽
2018/04/01
0
0

没有更多内容

加载失败,请刷新页面

加载更多

OSChina 周二乱弹 —— 开发语言和语言开发的能一样么

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @花间小酌:#今日歌曲推荐# 分享The Score的单曲《Revolution》 《Revolution》- The Score 手机党少年们想听歌,请使劲儿戳(这里) @批判派...

小小编辑
今天
591
8
oracle ORA-39700: database must be opened with UPGRADE option

ORA-01092: ORACLE instance terminated. Disconnection forced ORA-00704: bootstrap process failure ORA-39700: database must be opened with UPGRADE option 进程 ID: 3650 会话 ID: 29......

Tank_shu
今天
3
0
分布式协调服务zookeeper

ps.本文为《从Paxos到Zookeeper 分布式一致性原理与实践》笔记之一 ZooKeeper ZooKeeper曾是Apache Hadoop的一个子项目,是一个典型的分布式数据一致性的解决方案,分布式应用程序可以基于它...

ls_cherish
今天
4
0
聊聊DubboDefaultPropertiesEnvironmentPostProcessor

序 本文主要研究一下DubboDefaultPropertiesEnvironmentPostProcessor DubboDefaultPropertiesEnvironmentPostProcessor dubbo-spring-boot-project-2.7.3/dubbo-spring-boot-compatible/au......

go4it
昨天
2
0
redis 学习2

网站 启动 服务端 启动redis 服务端 在redis 安装目录下 src 里面 ./redis-server & 可以指定 配置文件或者端口 客户端 在 redis 的安装目录里面的 src 里面 ./redis-cli 可以指定 指定 连接...

之渊
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部