使用Docker安装常用中间件

使用Docker安装常用中间件

安装Docker Desktop

推荐参考文章

如果使用的是windows，请确保Wmware的版本为15.6+，15.5-的版本和docker desktop不兼容。

1、下载安装docker desktop

https://hub.docker.com/editions/community/docker-ce-desktop-windows

2、安装Kitematic

3、配置docker阿里云加速镜像

4、下载镜像 启动容器。

镜像操作

查看所有镜像

docker images

拉取镜像

docker pull imagesName[:version]

删除镜像 删除之前确保没有此镜像的容器

docker rmi image Id

Docker安装MySQL

#拉取镜像
docker pull mysql:5.7.25

#初始化 这里的-v是挂载目录，如果不需要可以删除
docker run -d --restart always --name mysql5725 -v D:\dev\docker\mysql\data:/var/lib/mysql -v D:\dev\docker\mysql:/etc/mysql/conf.d -v D:\dev\docker\mysql\logs:/logs -e MYSQL_ROOT_PASSWORD=<root用户的密码> -p 3306:3306 mysql:5.7.25

# linux
mkdir -p /docker/mysql/{logs,conf,data}
docker run -d --restart always --name mysql5725 -v /docker/mysql/conf:/etc/mysql/conf.d -v /docker/mysql/logs:/logs -v /docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=password -p 3306:3306 mysql:5.7.25


# 案例
mkdir -p /opt/mysql/{logs,conf,data}
docker run -d --restart always --name mysql5725 -v /opt/mysql/conf:/etc/mysql/conf.d -v /opt/mysql/logs:/logs -v /opt/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=3992209a. -p 13306:3306 mysql:5.7.25

#不挂载目录
docker run -d --name mysql5725 -e MYSQL_ROOT_PASSWORD=<root用户的密码> -p 3306:3306 mysql:5.7.25

#运行 进入容器
docker exec -it mysql5725 /bin/bash

# --restart always 开机自启

# ===========================开启远程访问===========================
# 进入容器内部
docker exec -it <自定义的容器ID> bash


// 登陆MySql
mysql -u root -p

// 设置root用户的远程访问权限
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '<root用户的密码>';

// 刷新权限
flush privileges;

Docker安装redis

#拉取镜像
docker pull redis

#指定版本号
docker pull redis:version /建议5.0.4

#下载redis配置文件，用于挂载
http://download.redis.io/redis-stable/redis.conf

#修改配置文件中的默认配置
bind 127.0.0.1 #注释掉这部分，这是限制redis只能本地访问
protected-mode no #默认yes，开启保护模式，限制为本地访问
daemonize no	#默认no，改为yes意为以守护进程方式启动，可后台运行，除非kill进程，改为yes会使配置文件方式启动redis失败
databases 16 #数据库个数（可选），我修改了这个只是查看是否生效。。
dir  ./ #输入本地redis数据库存放文件夹（可选）
appendonly yes #redis持久化（可选）


修改配置文件
`# bind 127.0.0.1`
protected-mode no

# windows 需要提前拷贝redis.conf到对应目录
docker run -p 6379:6379 --name redis504 -v D:\dev\docker\redis\conf\redis.conf:/etc/redis/redis.conf -v D:\dev\docker\redis\data:/data -d redis:5.0.4 redis-server /etc/redis/redis.conf --appendonly yes

# linux 需要提前拷贝redis.conf到对应目录
docker run -p 36379:6379 --name redis504 --restart always -v /home/dockerV/redis/redis.conf:/etc/redis/redis.conf -v /home/dockerV/redis/:/data -d redis:5.0.4 redis-server /etc/redis/redis.conf --appendonly yes
#如果挂载期间出现问题，请确保已经增加了文件夹的访问权限


# centos案例
docker run -p 6379:6379 --name redis504 --restart always -v /opt/redis:/etc/redis -v /opt/redis/data:/data -d redis:5.0.4 redis-server /etc/redis/redis.conf --appendonly yes

Docker安装Oracle

#拉取镜像
docker pull deepdiver/docker-oracle-xe-11g

#启动 挂载目录
docker run --name oracle11g -d -v D:\dev\docker\oracle:/data/oracle_data -p 1521:1521 -e ORACLE_ALLOW_REMOTE=true deepdiver/docker-oracle-xe-11g

#开启远程访问方式启动
docker run --name oracle11g --restart always -d -p 1521:1521 -v /home/dockerV/oracle_data:/data/oracle_data -e ORACLE_ALLOW_REMOTE=true deepdiver/docker-oracle-xe-11g


# 案例：
docker run --name oracle11g --restart always -d -p 11521:1521 -v /opt/oracle:/data/oracle_data -e ORACLE_ALLOW_REMOTE=true deepdiver/docker-oracle-xe-11g

#简单的启动方式
$ docker run --name oracle11g -d -p 1521:1521 deepdiver/docker-oracle-xe-11g

#连接信息
连接类型：Basic
主机地址：ip
端口：1521
SID：xe
用户名：system  sys
密码：oracle

#修改用户密码永久有效
1、查看用户的proifle是哪个，一般是default：

docker exec -it oracle11g bash
sqlplus
system
oracle

sql>SELECT username,PROFILE FROM dba_users;


2、查看指定概要文件（如default）的密码有效期设置：

sql>SELECT * FROM dba_profiles s WHERE s.profile='DEFAULT' AND resource_name='PASSWORD_LIFE_TIME';

3、将密码有效期由默认的180天修改成“无限制”：

sql>ALTER PROFILE DEFAULT LIMIT PASSWORD_LIFE_TIME UNLIMITED;

修改之后不需要重启动数据库，会立即生效。


# 创建表空间
create tablespace 表空间名称 datafile '表空间路径\文件名.dbf' size 初始大小m autoextend on next 增量 maxsize 最大值(unlimited为无限制);
# 案例
create tablespace rayf datafile '/data/oracle_data/rayf.dbf' size 1000m autoextend on next 100m maxsize unlimited;

# 常见错误 
ERROR at line 1:
ORA-01119: error in creating database file
'*****/**.dbf'
ORA-27040: file create error, unable to create file
Linux-x86_64 Error: 13: Permission denied

如果出现该错误就是权限不够，到要创建表空间的位置设置oracle权限
chown -R oracle:root /data/oracle_data/

# 在表空间内创建用户
create user 用户名称 identified by 密码 default tablespace 表空间;

# 案例
create user rayfoo identified by password default tablespace rayf;

# 授权
grant connect,resource to rayfoo;

grant dba to rayfoo;

配置PL/SQL

安装好oracle之后，安装PL/SQL，配置ORACLE客户端驱动。

1、下载instantclient_11_2

2、将加压后的文件夹配置为环境变量

key TNS_ADMIN
value D:\oracle\instantclient_11_2

3、在D:\oracle\instantclient_11_2创建两个文件

• tnsnames.ora

RXZQWEB_DEVDB =
  (DESCRIPTION =
    (ADDRESS_LIST =
      (ADDRESS = (PROTOCOL = TCP)(HOST = 127.0.0.1)(PORT = 1521))
    )
    (CONNECT_DATA =
      (SERVICE_NAME = xe)
    )
  )

• sqlnet.ora

SQLNET.AUTHENTICATION_SERVICES= (NTS)
NAMES.DIRECTORY_PATH= (TNSNAMES, EZCONNECT)

4、此时，插入中文可能会导致乱码，需要增加一个环境变量

key NLS_LANG
value AMERICAN_AMERICA.AL32UTF8

5、重启PL/SQL 问题解决

PL/SQL 、instantclient_11_2

链接：https://pan.baidu.com/s/1XMax_kI5nt0_BogKcSZIBw 
提取码：vhqh

Docker安装MongoDB

#拉取镜像
docker pull mongo:latest

#启动镜像
docker run -p 27017:27017 -v D:\docker-image\mongo:/data/db --name mongo -di mongo:latest

#simple
docker run -di --name=mongoDB -p 27017:27017 mongo:latest


# 创建用户
docker exec -it mongoDB bash
# 创建一个名为 admin，密码为 123456 的用户。
>  db.createUser({ user:'admin',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'},"readWriteAnyDatabase"]});
# 尝试使用上面创建的用户信息进行连接。
> db.auth('admin', '123456')

Docker安装ES

# 生产环境仅适用于内网部署或者增加了ip白名单。公网部署需要增加用户角色权限

#拉取镜像
docker pull elasticsearch:6.8.13

#启动
docker run -di --name=elasticsearch6813 -p 9200:9200 -p 9300:9300 -v D:\dev\docker\elasticsearch\conf\elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml -v D:\dev\docker\elasticsearch\data:/usr/share/elasticsearch/data -v D:\dev\docker\elasticsearch\plugins:/usr/share/elasticsearch/plugins  elasticsearch:6.8.13


# 5.x版本ES需要先运行=======5.6.16 linux==========
 sudo sysctl -w vm.max_map_count=262144
 
 docker run --name elasticsearch5616 -d \
 -p 9200:9200 -p 9300:9300 \
 -e "discovery.type=single-node" \
 -e ES_JAVA_OPS="-Xms1024m -Xmx2048m" \
 -v /opt/elasticsearch5/conf/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml -v /opt/elasticsearch5/data:/usr/share/elasticsearch/data \
-v /opt/elasticsearch5/plugins:/usr/share/elasticsearch/plugins elasticsearch:5.6.16
# 5.x版本ES需要先运行=======5.6.16 linux==========

# linux
mkdir -p /opt/elasticsearch/{conf,data,plugins}
touch /opt/elasticsearch/conf/elasticsearch.yml
vim /opt/elasticsearch/conf/elasticsearch.yml
# 加入下面代码块中的配置

#===============================elasticsearch.yml===============================

#服务端口号，在同一机器下必须不一样
http.port: 9200
# 集群名称
cluster.name: my-cluster
node.name: "master"
transport.host: 0.0.0.0
http.host: 0.0.0.0
# 支持跨域
http.cors.enabled: true
http.cors.allow-origin: "*"

#===============================elasticsearch.yml===============================
# 启动容器
docker run --name elasticsearch6813 -d -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPS="-Xms1024m -Xmx2048m" -e TAKE_FILE_OWNERSHIP=111 -v /opt/elasticsearch/conf/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml -v /opt/elasticsearch/data:/usr/share/elasticsearch/data -v /opt/elasticsearch/plugins:/usr/share/elasticsearch/plugins elasticsearch:6.8.13


# 启动容器 7.7.0
mkdir -p /opt/elasticsearch/{data,plugins,config}
touch /opt/elasticsearch/config/elasticsearch.yml

chmod 777 /opt/elasticsearch/data

docker pull elasticsearch:7.7.0

docker run --name elasticsearch770 -p 9200:9200 \
 -p 9300:9300 \
 -e "discovery.type=single-node" \
 -e ES_JAVA_OPTS="-Xms1024m -Xmx4096m" \
  -v /opt/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
 -v /opt/elasticsearch/data:/usr/share/elasticsearch/data \
 -v /opt/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
 -d elasticsearch:7.7.0

# 注意：linux下docker如果要挂载/usr/share/elasticsearch/data需要加上-e TAKE_FILE_OWNERSHIP=111
# 如果挂载的目录都会新建文件夹，都需要加上-e TAKE_FILE_OWNERSHIP=111
# elk下载地址：https://www.elastic.co/downloads/past-releases#kibana

elasticsearch.yml详细配置

cluster.name: elasticsearch
配置es的集群名称，默认是elasticsearch，es会自动发现在同一网段下的es，如果在同一网段下有多个集群，就可以用这个属性来区分不同的集群。
node.name: "Franz Kafka"
节点名，默认随机指定一个name列表中名字，该列表在es的jar包中config文件夹里name.txt文件中，其中有很多作者添加的有趣名字。
node.master: true
指定该节点是否有资格被选举成为node，默认是true，es是默认集群中的第一台机器为master，如果这台机挂了就会重新选举master。
node.data: true
指定该节点是否存储索引数据，默认为true。
index.number_of_shards: 5
设置默认索引分片个数，默认为5片。
index.number_of_replicas: 1
设置默认索引副本个数，默认为1个副本。
path.conf: /path/to/conf
设置配置文件的存储路径，默认是es根目录下的config文件夹。
path.data: /path/to/data
设置索引数据的存储路径，默认是es根目录下的data文件夹，可以设置多个存储路径，用逗号隔开，例：
path.data: /path/to/data1,/path/to/data2
path.work: /path/to/work
设置临时文件的存储路径，默认是es根目录下的work文件夹。
path.logs: /path/to/logs
设置日志文件的存储路径，默认是es根目录下的logs文件夹
path.plugins: /path/to/plugins
设置插件的存放路径，默认是es根目录下的plugins文件夹
bootstrap.mlockall: true
设置为true来锁住内存。因为当jvm开始swapping时es的效率会降低，所以要保证它不swap，可以把ES_MIN_MEM和 ES_MAX_MEM两个环境变量设置成同一个值，并且保证机器有足够的内存分配给es。同时也要允许elasticsearch的进程可以锁住内存，linux下可以通过`ulimit -l unlimited`命令。
network.bind_host: 192.168.0.1
设置绑定的ip地址，可以是ipv4或ipv6的，默认为0.0.0.0。 
network.publish_host: 192.168.0.1
设置其它节点和该节点交互的ip地址，如果不设置它会自动判断，值必须是个真实的ip地址。
network.host: 192.168.0.1
这个参数是用来同时设置bind_host和publish_host上面两个参数。
transport.tcp.port: 9300
设置节点间交互的tcp端口，默认是9300。
transport.tcp.compress: true
设置是否压缩tcp传输时的数据，默认为false，不压缩。
http.port: 9200
设置对外服务的http端口，默认为9200。
http.max_content_length: 100mb
设置内容的最大容量，默认100mb
http.enabled: false
是否使用http协议对外提供服务，默认为true，开启。
gateway.type: local
gateway的类型，默认为local即为本地文件系统，可以设置为本地文件系统，分布式文件系统，Hadoop的HDFS，和amazon的s3服务器。
gateway.recover_after_nodes: 1
设置集群中N个节点启动时进行数据恢复，默认为1。
gateway.recover_after_time: 5m
设置初始化数据恢复进程的超时时间，默认是5分钟。
gateway.expected_nodes: 2
设置这个集群中节点的数量，默认为2，一旦这N个节点启动，就会立即进行数据恢复。
cluster.routing.allocation.node_initial_primaries_recoveries: 4
初始化数据恢复时，并发恢复线程的个数，默认为4。
cluster.routing.allocation.node_concurrent_recoveries: 2
添加删除节点或负载均衡时并发恢复线程的个数，默认为4。
indices.recovery.max_size_per_sec: 0
设置数据恢复时限制的带宽，如入100mb，默认为0，即无限制。
indices.recovery.concurrent_streams: 5
设置这个参数来限制从其它分片恢复数据时最大同时打开并发流的个数，默认为5。
discovery.zen.minimum_master_nodes: 1
设置这个参数来保证集群中的节点可以知道其它N个有master资格的节点。默认为1，对于大的集群来说，可以设置大一点的值（2-4）
discovery.zen.ping.timeout: 3s
设置集群中自动发现其它节点时ping连接超时时间，默认为3秒，对于比较差的网络环境可以高点的值来防止自动发现时出错。
discovery.zen.ping.multicast.enabled: false
设置是否打开多播发现节点，默认是true。
discovery.zen.ping.unicast.hosts: ["host1", "host2:port", "host3[portX-portY]"]
设置集群中master节点的初始列表，可以通过这些节点来自动发现新加入集群的节点。
下面是一些查询时的慢日志参数设置
index.search.slowlog.level: TRACE
index.search.slowlog.threshold.query.warn: 10s
index.search.slowlog.threshold.query.info: 5s
index.search.slowlog.threshold.query.debug: 2s
index.search.slowlog.threshold.query.trace: 500ms
index.search.slowlog.threshold.fetch.warn: 1s
index.search.slowlog.threshold.fetch.info: 800ms
index.search.slowlog.threshold.fetch.debug:500ms
index.search.slowlog.threshold.fetch.trace: 200ms

Docker安装RabbitMQ

#拉取镜像
docker pull rabbitmq:management

#启动
docker run -di --name=rabbitmq_management -p 5671:5617 -p 5672:5672 -p 4369:4369 -p 15671:15671 -p 15672:15672 -p 25672:25672 rabbitmq:management

Docker安装Zookeeper

#拉取镜像
docker pull zookeeper

#启动
docker run --privileged=true -d --name zookeeper --publish 2181:2181 -d zookeeper:latest

Docker安装Solr

#下载镜像
docker pull solr:7.5.0

#启动solr容器
docker run --name my-solr -d -p 8983:8983 -t solr:7.5.0

#访问solr后台
在浏览器中打开http://localhost:8983/solr/#/，即可进入solr管理界面

#新建solrCore
新建solrCore,名称为mycore,执行：docker run --name my-solr -d -p 8983:8983 -t solr:7.5.0

#Solr配置持久化
#将容器中solr的配置拷贝到宿主机的共享volume中，实现配置持久化。由于我的共享volume是在F盘中
#所以执行下面的命令：
docker cp my-solr:/opt/solr/ f:/data/solr/

#设置中文分词库smartcn
-以root身份进入容器内部：docker exec -it --user root my-solr /bin/bash
-定位Solr7自带的中文分词jar包所在位置：/opt/solr/contrib/analysis-extras/lucene-libs
-进入刚才创建的solr core 的位置：/opt/solr/server/solr/mycore/conf，修改 solrconfig.xml 添加 smartcn 包的 lib 标签
-在managed-schema中添加中文分词的FieldType
-将新增的配置同步到宿主的共享volume：docker cp my-solr:/opt/solr/server/solr/mycore/conf/solrconfig.xml f:/data/solr/solr/server/solr/mycore/conf/solrconfig.xml
docker cp my-solr:/opt/solr/server/solr/mycore/conf/managed-schema f:/data/solr/solr/server/solr/mycore/conf/managed-schema

重启solr: docker restart my-solr

进入Docker的Solr容器，执行很多命令都报权限不足：Permission denied
解决办法：docker exec -it --user root my-solr /bin/bash

https://blog.csdn.net/webofrxy/article/details/88585810

Docker安装SVN

# 拉取镜像
docker search svn
docker pull docker.io/garethflowers/svn-server
docker images

# 启动容器
docker run -v D:\docker-image\svnr_repo:/var/opt/svn --name svn-server -p 3690:3690 --privileged=true -e SVN_REPONAME=repository -d docker.io/garethflowers/svn-server

# 参考-
#https://www.cnblogs.com/xiaofengfree/p/13099434.html

# 进入容器内部
docker exec -it svn-server /bin/sh
# 创建一个仓库，名为repository
svnamin create /var/opt/svn/repository
# 进入仓库的配置文件
cd /var/opt/svn/repository/conf
# 使用vim编辑配置文件
vi svnserve.conf
# 打开anon-access = read
# 打开auth-access = write
# 打开password-db = passwd
# 打开authz-db = authz
# 使用vi编辑这个目录下的password
vi password
# 添加一个或多个用户
[users]
user1 = password1
user2 = password2
# 编辑当前目录下的authz 修改权限相关配置
vi authz
# 在[groups]中加入一个组，并且给刚才添加的用户添加到组中(rayfoo,giao)都是刚才添加的用户
[groups]
group1 = rayfoo,giao

# 在[repository:/]中添加权限信息
[respository:/]
@group1 = rw

#保存并退出 重启svn服务
exit
docker restart svn-server


# 客户端拉取
svn co svn://ip/project

http://www.pgygho.com/help/fwq/18791.html

Docker安装WebLogic

docker pull ismaleiva90/weblogic12

docker run --name weblogic -d -p 7001:7001 -p 7002:7002 -p 5556:5556 ismaleiva90/weblogic12:latest

http://localhost:7001/console/

用户名：  weblogic
密码：    welcome1

Docker安装Nacos

docker pull nacos/nacos-server


mkdir -p /root/nacos/init.d /root/nacos/logs
touch /root/nacos/init.d/custom.properties

#如果是windows自行脑部即可

 在文件中写入以下配置
management.endpoints.web.exposure.include=*


docker run -d -p 8848:8848 -e MODE=standalone -e PREFER_HOST_MODE=hostname -v D:\dev\docker\nacos\init.d\custom.properties:/home/nacos/init.d/custom.properties -v D:\dev\docker\nacos\logs:/home/nacos/logs --name nacos nacos/nacos-server

127.0.0.1:8848/nacos  
nacos/nacos

开机自启 --restart always

参考mysql案例

Docker安装Nginx

容器里不能使用localhoat，必须使用具体的ip地址才行。 而且还是存在一定的问题，不推荐使用

docker pull nginx:1.16.1

docker run --name nginx-web -p 80:80 -d nginx:1.16.1

docker run -d -p 80:80 --name nginx-web -v D:\dev\docker\nginx\www:/etc/nginx/html -v D:\dev\docker\nginx\conf\nginx.conf:/etc/nginx/nginx.conf -v D:\dev\docker\nginx\logs:/var/log/nginx nginx:1.16.1

# 创建映射目录
mkdir -p /docker/nginx/{html,conf,logs}

# 启动容器
docker run -d -p 8013:80 --name nginx-hgzsk-ui -v /docker/nginx/html:/etc/nginx/html -v /docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /docker/nginx/logs:/var/log/nginx nginx:1.16.1

nginx的配置文件要进行基本配置 否则无法正常启动

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }

    # server{
    #     listen 80;
    #     charset utf-8;
    #     server_name 192.168.112.135;

    #     location / {
    #         proxy_pass http://192.168.112.135:8080;
    #         proxy_redirect default;
    #     }
    # }
    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

Docker安装jenkins

参考：https://segon.cn/install-jenkins-using-docker.html

docker pull jenkins/jenkins:latest	#拉取jenkins镜像 


在D盘下创建`D:\dev\docker\jenkins_home` #在本地创建目录 用于映射jenkins  windows环境直接创建即可


docker run -d --name jenkins --restart always -p 8080:8080 -p 50000:50000 -v D:\dev\docker\jenkins:/var/jenkins_home jenkins/jenkins:2.222.3-centos  #映射端口、目录


# linux or macos macos 需要sudo
docker run -d -u --privileged=true --name jenkins --restart always -p 12360:8080 -v /opt/jenkins:/var/jenkins_home jenkins/jenkins



# 启动 jenkins
启动成功后，打开浏览器，输入localhost:8040

# 重启 jenkins
ip:port/restart

进入docker容器，获取初始密码
docker exec jenkins_gitlab cat /var/jenkins_home/secrets/initialAdminPassword


# 阿里云jenkins账号密码备份
rayfoo@qq.com
3992209a.

# sino143
rayfoo 3992209a.



#中文插件
Locale

# gitee插件
gitee


===============================  403解决  ===============================

# 开启匿名访问
系统管理-全局安全配置-授权策略-匿名访问具有可读权限

# 开启代理兼容
系统管理-全局安全配置-跨站请求伪造保护-开启 启用代理兼容

# 进入jenkins容器
docker exec -it xxx bash

# 建议端口映射不要修改 否则可能会403

# 编辑配置文件 1 /usr/local/bin/jenkins.sh
修改/usr/local/bin/jenkins.sh , 找到exec java那行,添加-Dhudson.security.csrf.GlobalCrumbIssuerConfiguration.DISABLE_CSRF_PROTECTION=true，保存退出

# 编辑配置文件 2 最终效果
exec java -Duser.home="$JENKINS_HOME" -Dhudson.security.csrf.GlobalCrumbIssuerConfiguration.DISABLE_CSRF_PROTECTION=true "${java_opts_array[@]}" -jar ${JENKINS_WAR} "${jenkins_opts_array[@]}" "$@"


===============================  403解决  ===============================




# Jenkins时间和宿主机不同步问题
docker exec -it jenkins bash
echo Asia/Shanghai >/etc/timezone
exit
docker cp /etc/localtime jenkins:/etc/localtime


系统管理-管理用户-设置，将用户的时区修改为亚洲 上海即可。

Docker安装hdfs

参考：https://www.cnblogs.com/hongdada/p/9488349.html

# 安装docker compose依赖
yum -y install epel-release

# 安装依赖
yum -y install python-pip

cd /usr/local/bin/

# 拉取包
wget https://github.com/docker/compose/releases/download/1.14.0-rc2/docker-compose-Linux-x86_64

# 更名
rename docker-compose-Linux-x86_64 docker-compose docker-compose-Linux-x86_64

# 授权
chmod +x /usr/local/bin/docker-compose

# 回到存放yml的目录
cd /docker/hdfs

# 拉取镜像
docker pull singularities/hadoop

# 创建compose配置文件
touch docker-compose.yml

# 输入下面的yml文件
vim docker-compose.yml
# 在运行命令的目录创建docker-compose.yml 添加如下配置

version: "2"

services:
  namenode:
    image: singularities/hadoop
    command: start-hadoop namenode
    hostname: namenode
    environment:
      HDFS_USER: hdfsuser
    ports:
      - "8020:8020"
      - "14000:14000"
      - "50070:50070"
      - "50075:50075"
      - "10020:10020"
      - "13562:13562"
      - "19888:19888"
  datanode:
    image: singularities/hadoop
    command: start-hadoop datanode namenode
    environment:
      HDFS_USER: hdfsuser
    links:
      - namenode

docker-compose up --no-recreate -d

记得开放端口哦

稍等片刻，在浏览器输入http://ip:50070/dfshealth.html#tab-datanode

HDFS常用命令

hdfs基础命令：

1、创建目录

hadoop fs -mkdir /hdfs #在根目录下创建hdfs文件夹
2、查看目录

>hadoop fs -ls / #列出跟目录下的文件列表
drwxr-xr-x   - root supergroup          0 2016-03-05 00:06 /hdfs
3、级联创建目录

>hadoop fs -mkdir -p /hdfs/d1/d2
4、级联列出目录

>hadoop fs -ls -R /
drwxr-xr-x   - root supergroup          0 2016-03-05 00:10 /hdfs
drwxr-xr-x   - root supergroup          0 2016-03-05 00:10 /hdfs/d1
drwxr-xr-x   - root supergroup          0 2016-03-05 00:10 /hdfs/d1/d2
5、上传本地文件到HDFS

>echo "hello hdfs" >>local.txt
>hadoop fs -put local.txt /hdfs/d1/d2
6、查看HDFS中文件的内容

>hadoop fs -cat /hdfs/d1/d2/local.txt
hello hdfs
7、下载hdfs上文件的内容

>hadoop fs -get /hdfs/d1/d2/local.txt
8、删除hdfs文件

>hadoop fs -rm /hdfs/d1/d2/local.txt
Deleted /hdfs/d1/d2/local.txt
9、删除hdfs中目录

>hadoop fs -rmdir /hdfs/d1/d2
10、修改文件的权限

>hadoop fs -ls /hdfs
drwxr-xr-x   - root supergroup          0 2016-03-05 00:21 /hdfs/d1 #注意文件的权限
>hadoop fs -chmod 777 /hdfs/d1
drwxrwxrwx   - root supergroup          0 2016-03-05 00:21 /hdfs/d1 #修改后
11、修改文件所属的用户

>hadoop fs -chown admin /hdfs/d1 #修改文件所属用户为admin
>hadoop fs -ls /hdfs
drwxrwxrwx   - admin supergroup          0 2016-03-05 00:21 /hdfs/d1
12、修改文件的用户组

>hadoop fs -chgrp admin /hdfs/d1
>hadoop fs -ls /hdfs
drwxrwxrwx   - admin admin          0 2016-03-05 00:21 /hdfs/d1

Docker安装consul

docker pull consul
mkdir -p /opt/consul/{conf,data}
docker run \
--name consul \
--restart always \
-p 8500:8500 \
--log-opt max-size=500m \
-v /opt/consul/conf/:/consul/conf/ \
-v /opt/consul/data/:/consul/data/ \
-d consul


docker run \
--name consul-dev \
--log-opt max-size=500m \
-p 8599:8500 \
-d consul

docker run \
--name consul-test \
--log-opt max-size=500m \
-p 8600:8500 \
-d consul


# consul日志非常大，可以增加--log-opt max-size=500m参数限制它的大小

Docker安装tomcat

# 拉取镜像
docker pull tomcat:8.5.66

# 创建映射目录
mkdir -p /docker/tomcat/opt

# 创建一个临时容器，用于拷贝文件
docker run -d --rm --name tomcat-test tomcat:8.5.66

# 复制文件
docker cp tomcat-test:/usr/local/tomcat/conf /docker/tomcat
docker cp tomcat-test:/usr/local/tomcat/webapps /docker/tomcat

# 停止并删除容器
docker stop tomcat-test

# 正式创建容器
docker run --name tomcat8566 -d -p 8080:8080 -v /docker/tomcat/opt:/opt -v /docker/tomcat/conf:/usr/local/tomcat/conf -v /docker/tomcat/webapps:/usr/local/tomcat/webapps tomcat:8.5.66

Docker安装PostgreSQL

阿里云RDS - Postgres的推荐版本是12和11，这里我们选择12的版本进行安装。

docker pull postgres:12.4

docker run --name postgres12_4 -e POSTGRES_PASSWORD=3992209a. -e TZ=PRC -p 15432:5432 -v /docker/postgres/data:/var/lib/postgresql/data -d postgres:12.4

Docker安装Redis集群

0.安装docker-compose

# 下载 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
# 将可执行权限应用于二进制文件：
sudo chmod +x /usr/local/bin/docker-compose
# 创建软链：
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

1.创建数据目录

[root@localhost redis]# pwd
/data/redis
[root@localhost redis]# mkdir -p 700{1..6}/data  ##这个目录和下边yml文件的volumes对应
[root@localhost redis]# ls 
7001  7002  7003  7004  7005  7006  docker-compose.yml

2.开放7001-7006端口

3.创建一个docker-compose.yml文件，内容如下：

version: '3'

services:
 redis1:
  image: publicisworldwide/redis-cluster
  network_mode: host
  restart: always
  volumes:
   - /data/redis/7001/data:/data
  environment:
   - REDIS_PORT=7001

 redis2:
  image: publicisworldwide/redis-cluster
  network_mode: host
  restart: always
  volumes:
   - /data/redis/7002/data:/data
  environment:
   - REDIS_PORT=7002

 redis3:
  image: publicisworldwide/redis-cluster
  network_mode: host
  restart: always
  volumes:
   - /data/redis/7003/data:/data
  environment:
   - REDIS_PORT=7003

 redis4:
  image: publicisworldwide/redis-cluster
  network_mode: host
  restart: always
  volumes:
   - /data/redis/7004/data:/data
  environment:
   - REDIS_PORT=7004

 redis5:
  image: publicisworldwide/redis-cluster
  network_mode: host
  restart: always
  volumes:
   - /data/redis/7005/data:/data
  environment:
   - REDIS_PORT=7005

 redis6:
  image: publicisworldwide/redis-cluster
  network_mode: host
  restart: always
  volumes:
   - /data/redis/7006/data:/data
  environment:
   - REDIS_PORT=7006

# 启动
docker-compose up --no-recreate -d

# 进入任意一个节点
docker exec -ti xxxx bash

# 配置节点信息 IP替换为宿主机IP
redis-cli --cluster create 192.168.1.100:7001 192.168.1.100:7002 192.168.1.100:7003 192.168.1.100:7004 192.168.1.100:7005 192.168.1.100:7006 --cluster-replicas 1

>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.168.1.100:7004 to 192.168.1.100:7001
Adding replica 192.168.1.100:7005 to 192.168.1.100:7002
Adding replica 192.168.1.100:7006 to 192.168.1.100:7003
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: 7237efa105ff4246c02da08c0e65c18246755f2f 192.168.1.100:7001
   slots:[0-5460] (5461 slots) master
M: 241d6eb2abcd9a6d41db5231fcd80fac1d452bee 192.168.1.100:7002
   slots:[5461-10922] (5462 slots) master
M: 493083f2733bc181295f5b9a9fa9bc6fdf821958 192.168.1.100:7003
   slots:[10923-16383] (5461 slots) master
S: b60ef6cbea0ae06566d17db4a1b4452e56543419 192.168.1.100:7004
   replicates 241d6eb2abcd9a6d41db5231fcd80fac1d452bee
S: b48e546e963f694eac91d49b285040bb2bec5513 192.168.1.100:7005
   replicates 493083f2733bc181295f5b9a9fa9bc6fdf821958
S: 259de2d6be917e64cdc01604521da45cc1f8d842 192.168.1.100:7006
   replicates 7237efa105ff4246c02da08c0e65c18246755f2f
Can I set the above configuration? (type 'yes' to accept): yes

# 输入yes
yes


>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
....
>>> Performing Cluster Check (using node 192.168.1.100:7001)
M: 7237efa105ff4246c02da08c0e65c18246755f2f 192.168.1.100:7001
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: 241d6eb2abcd9a6d41db5231fcd80fac1d452bee 192.168.1.100:7002
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
M: 493083f2733bc181295f5b9a9fa9bc6fdf821958 192.168.1.100:7003
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: b60ef6cbea0ae06566d17db4a1b4452e56543419 192.168.1.100:7004
   slots: (0 slots) slave
   replicates 241d6eb2abcd9a6d41db5231fcd80fac1d452bee
S: 259de2d6be917e64cdc01604521da45cc1f8d842 192.168.1.100:7006
   slots: (0 slots) slave
   replicates 7237efa105ff4246c02da08c0e65c18246755f2f
S: b48e546e963f694eac91d49b285040bb2bec5513 192.168.1.100:7005
   slots: (0 slots) slave
   replicates 493083f2733bc181295f5b9a9fa9bc6fdf821958
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

# ok

Docker容器内安装vim

apt-get update

apt-get install vim



# 使用cat添加文本
cat >/path/filename <<EOF
commandline
commandline
EOF

# 案例 cat会覆盖原本的内容。
cat >~/.bashrc <<EOF
export PATH=/opt/java/openjdk/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/bin:/opt/maven383/bin
EOF

Docker安装gitlab

mkdir -p /opt/gitlab/config
mkdir -p /opt/gitlab/logs
mkdir -p /opt/gitlab/data

docker pull gitlab/gitlab-ce:latest

# 如果内网的80改成了18080 那么绑定端口就要写成18080:18080 
sudo docker run --detach \
--publish 10443:443 --publish 18080:18080 --publish 10022:22 \
--name gitlab \
--restart always \
--volume /opt/gitlab/config:/etc/gitlab \
--volume /opt/gitlab/logs:/var/log/gitlab \
--volume /opt/gitlab/data:/var/opt/gitlab \
gitlab/gitlab-ce:latest


# 案例
sudo docker run --detach \
--publish 10443:443 --publish 12362:12362 --publish 10022:22 \
--name gitlab \
--restart always \
--volume /opt/gitlab/config:/etc/gitlab \
--volume /opt/gitlab/logs:/var/log/gitlab \
--volume /opt/gitlab/data:/var/opt/gitlab \
gitlab/gitlab-ce:latest

# 修改配置
vi /opt/gitlab/config/gitlab.rb

# 一定记得带上http://
external_url 'http://ip:18080'
	
# 初始化配置	
docker exec -ti gitlab /bin/bash
gitlab-ctl reconfigure  #花时间比较多 卡住的话没关系 听首歌再过来看 报错了重新跑。
gitlab-ctl restart    #重启后一分钟内可能会502 稍等一下就ok

# 查看root密码 进入容器后查看
cat /etc/gitlab/initial_root_password

Docker安装minIO

# 拉取镜像
docker pull bitnami/minio


# 启动容器
docker run --name minio \
 -d \
--privileged=true \
-e TZ="Asia/Shanghai" \
--publish 9000:9000 \
--publish 9001:9001 \
--env "MINIO_ACCESS_KEY=rayfoo" \
--env "MINIO_SECRET_KEY=3992209a." \
--volume /opt/minio/data:/data \
--volume /opt/minio/config:/root/.minio \
bitnami/minio:latest

# 查看日志发现报错信息 /opt/bitnami/scripts/libminio.sh: line 270: /data/.root_user: Permission denied
# 解决办法 ，提前创建好此文件夹应该也能避免这个问题，容器创建的文件夹没有权限 需要手动授权。：
chmod 777 /opt/minio/data
chmod 777 /opt/minio/config

# 重启容器
docker restart minio

    
# 浏览器访问    
http://ip:9001

# 输入rayfoo 3992209a.登录

--restart always使用的一个小tips

我的阿里云服务器是2c4g，部署的所有容器都加了 --restart always，当更换了镜像加速后，docker重启，所有容器都自动启动服务器直接宕机。。

所以建议除了Redis、MySQL、Oracle等需要保证4x24开启的容器自动启动外，其余容器如果要设置自动启动那一定要考虑服务器的配置。

Docker安装janusgraph

# 下载容器
docker pull janusgraph/janusgraph:latest
# 启动服务端
docker run --privileged=true --name janusgraph-default -d -p 8182:8182 janusgraph/janusgraph:latest

# 启动客户端
docker run --rm --link janusgraph-default:janusgraph \
-e GREMLIN_REMOTE_HOSTS=janusgraph \
-it janusgraph/janusgraph:latest ./bin/gremlin.sh



         \,,,/
         (o o)
-----oOOo-(3)-oOOo-----
plugin activated: janusgraph.imports
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.hadoop
plugin activated: tinkerpop.spark
plugin activated: tinkerpop.tinkergraph

# 连接到客户端
gremlin> :remote connect tinkerpop.server conf/remote.yaml
==>Configured janusgraph/172.17.0.2:8182

# 添加一个key
gremlin> :> g.addV('person').property('name', 'chris')
==>v[4160]

# 查询一个key
gremlin> :> g.V().values('name')
==>chris

Docker安装HBase

# 查找最多人用的镜像
docker search hbase

# 拉取镜像
docker pull harisekhon/hbase

# 后台启动容器，自动映射端口
docker run -d --name hbase001 -P harisekhon/hbase

# 查看端口映射情况 
docker ps

# 找到16010端口映射的地址 我这里是49155,通过浏览器访问：
http://192.168.90.143:49155

Docker安装Oracle19C

# 创建用于挂载的目录
mkdir -p /opt/oracle
chmod 777 /opt/oracle

# 拉取镜像
docker pull registry.cn-hangzhou.aliyuncs.com/zhuyijun/oracle:19c

# 启动容器
docker run --restart always --privileged=true -d -p 1521:1521 -p 5500:5500 \
-e ORACLE_SID=orcl \
-e ORACLE_PDB=orclpdb1 \
-e ORACLE_PWD=password \
-e ORACLE_CHARACTERSET=zhs16gbk \
-e ORACLE_BASE=/opt/oracle \
-e ORACLE_HOME=/opt/oracle/product/19c/dbhome_1 \
-e PATH=/opt/oracle/product/19c/dbhome_1/bin:/opt/oracle/product/19c/dbhome_1/OPatch/:/usr/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
-v /opt/oracle:/opt/oracle/oradata \
--name oracle19c \
registry.cn-hangzhou.aliyuncs.com/zhuyijun/oracle:19c

# 默认的password密码是对应system用户

#等待容器创建成功后 修改密码
docker exec  oracle19c ./setPassword.sh password

Docker安装FastDFS

# 搜索镜像
docker search fastdfs

# 拉取镜像（已经内置Nginx）
docker pull delron/fastdfs

# 构建Tracker
# 22122 => Tracker默认端口
docker run --name=tracker-server --privileged=true -p 22122:22122 -v /opt/fdfs/tracker:/var/fdfs -d delron/fastdfs tracker

# 构建Storage
# 23000 => Storage默认端口
# 8888 => 内置Nginx默认端口
# TRACKER_SERVER => 执行Tracker的ip和端口
# --net=host => 避免因为Docker网络问题导致外网客户端无法上传文件，因此使用host网络模式需要使用：23000 8888端口
docker run --name=storage-server --net=host --privileged=true -v /opt/fdfs/storage:/var/fdfs -e TRACKER_SERVER=192.168.90.133:22122 -e GROUP_NAME=group1 -d delron/fastdfs storage

# 查看容器
docker ps

测试上传和访问#

• 将图片上传到服务器/var/fdfs/storage/
• 进入storage-server

docker exec -it storage-server /bin/bash

cd /var/fdfs/

/usr/bin/fdfs_upload_file /etc/fdfs/client.conf test.jpg

# 记录返回的文件名称（卷名和文件名）信息

http://192.168.90.133:58888/group1/M00/00/00/rBEACF8wzPaATSdKAAEQy6lDthg207.jpg