mysql|tomcat|nginx|redis 在 docker 中的部署（docker部署mysql的好处）

25-04-08 4

本文将介绍mysql|tomcat|nginx|redis在docker中的部署的详细情况，特别是关于docker部署mysql的好处的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地

本文将介绍mysql|tomcat|nginx|redis 在 docker 中的部署的详细情况，特别是关于docker部署mysql的好处的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于CentOS6.5+JDK+Tomcat+Mysql+Nginx负载均衡+Redis环境部署、Centos7中Docker安装 portainer、jenkins、svn 、tomcat、mysql、nginx、redis等常用容器、CentOS7中Docker安装tomcat、redis、mysql 8.0、CentOS7中Docker应用部署（MySQL、Tomcat、Nginx、Redis）的知识。

本文目录一览：

mysql|tomcat|nginx|redis 在 docker 中的部署（docker部署mysql的好处）
CentOS6.5+JDK+Tomcat+Mysql+Nginx负载均衡+Redis环境部署
Centos7中Docker安装 portainer、jenkins、svn 、tomcat、mysql、nginx、redis等常用容器
CentOS7中Docker安装tomcat、redis、mysql 8.0
CentOS7中Docker应用部署（MySQL、Tomcat、Nginx、Redis）

mysql|tomcat|nginx|redis 在 docker 中的部署（docker部署mysql的好处）

MySQL 部署

拉取 MySQL 镜像

docker pull mysql

　查看镜像

创建 MySQL 容器

docker run -di --name pinyougou_mysql -p 33306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

-p 代表端口映射，格式为宿主机映射端口：容器运行端口

-e 代表添加环境变量 MYSQL_ROOT_PASSWORD 是 root 用户的登陆密码

进入 MySQL 容器，登陆 MySQL

进入 mysql 容器

docker exec -it pinyougou_mysql /bin/bash

登陆 mysql

mysql -u root -p

远程登陆 MySQL

（1）我们在我们本机的电脑上去连接虚拟机 Centos 中的 Docker 容器，这里 192.168.247.130 是虚拟机操作系统的 IP

（2）在本地客户端执行建库脚本

执行 “资源 / 建库语句 /pinyougoudb.sql”

查看容器 IP 地址

我们可以通过以下命令查看容器运行的各种数据

docker inspect pinyougou_mysql

运行效果如下：

我们可以看到我们的数据库服务器的 IP 是 172.17.0.2

tomcat 部署

拉取 tomcat 镜像

docker pull tomcat:7-jre7

创建 tomcat 容器

创建容器用于部署单点登录系统（CAS） -p 表示地址映射

docker run -di --name=pinyougou_tomcat -p 9000:8080

-v /usr/local/myhtml:/usr/local/tomcat/webapps --privileged=true tomcat:7-jre7

部署 web 应用

（1）修改 cas 系统的配置文件，修改数据库连接的 url

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

p:driverClass="com.mysql.jdbc.Driver"

p:jdbcUrl="jdbc:mysql://172.17.0.6:3306/pinyougoudb?characterEncoding=utf8"

p:user="root"

p:password="123456" />

测试：地址栏输入：http://192.168.247.135:9000/cas/login

Nginx 部署

拉取 Nginx 镜像

docker pull nginx

创建 Nginx 容器

docker run -di --name=pinyougou_nginx -p 80:80  nginx/bin/bash

测试 Nginx

浏览器地址栏输入： http://192.168.247.135

配置反向代理

官方的 nginx 镜像，nginx 配置文件 nginx.conf 在 /etc/nginx/ 目录下。

在容器内编辑配置文件不方便，我们可以先将配置文件从容器内拷贝到宿主机，编辑修改后再拷贝回去。

（1）从容器拷贝配置文件到宿主机

docker cp pinyougou_nginx:/etc/nginx/nginx.conf nginx.conf

（2）编辑 nginx.conf，添加反向代理配置

upstream tomcat-cas {

server 172.17.0.7:8080;

}

server {

listen 80;

server_name passport.pinyougou.com;

location / {

proxy_pass http://tomcat-cas;

index index.html index.htm;

}

}

（3）将修改后的配置文件拷贝到容器

docker cp nginx.conf  pinyougou_nginx:/etc/nginx/nginx.conf

（4）重新启动容器

docker restart pinyougou_nginx

（5）设置域名指向

192.168.247.135 passport.pinyougou.com

浏览器测试：http://passport.pinyougou.com/cas/login

Redis 部署

拉取 Redis 镜像

docker pull redis

创建 Redis 容器

 docker run -di --name=pinyougou_redis -p 6379:6379 redis

客户端测试

在你的本地电脑命令提示符下，用 window 版本 redis 测试

redis-cli -h 192.168.247.135

CentOS6.5+JDK+Tomcat+Mysql+Nginx负载均衡+Redis环境部署

1. CentOS6.5直接申请阿里云ECS实例，不再累述。

Windows安装XShell作为SSH客户端，安装Xftp5作为文件传输的客户端。

2. JDK安装：

（1）下载JDK tar包，地址：

http://www.Oracle.com/technetwork/Java/javase/downloads/jdk8-downloads-2133151.html

选择Linuxx64：jdk-8u101-linux-x64.tar.gz

通过Xftp5将tar包上传到CentOS6.5的root目录下

解压tar包：#tar -zxvf jdk-8u101-linux-x64.tar.gz

（2）JDK目录移植到/usr/java：

#mkdir /usr/java

#mv jdk1.8.0_92 /usr/java

（3）设置环境变量：

#vim /etc/profile

按i键进入编辑状态，文档末尾追加如下内容：

JAVA_HOME=/usr/java/jdk1.8.0_92

CLAsspATH=$JAVA_HOME/lib:$JAVA_HOME/jre/lib:$CATALINE_HOME/lib
PATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME/jre/bin
export PATH CLAsspATH JAVA_HOME

按esc键退出编辑状态，输入:wq，保存退出

让刚刚设置的环境变量立即生效：#source /etc/profile

（4）验证：

#java -version

输出：

Javaversion "1.8.0_92"
Java(TM) SE Runtime Environment (build 1.8.0_92-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.92-b14,mixed mode)

3. Tomcat安装：

（1）下载Tomcat tar包，地址：

http://tomcat.apache.org/download-70.cgi

选择Core，tar.gz

通过Xftp5将tar包上传到CentOS6.5的root目录下

解压tar包：#tar -zxvf apache-tomcat-7.0.72.tar.gz

（2）Tomcat目录移植到/usr/local：

#mv apache-tomcat-7.0.72 /usr/local/tomcat

（3）启动Tomcat

#cd /usr/local/tomcat/bin

#./startup.sh

（4）验证：

Windows浏览器访问http://****(CentOS外网地址):8080，出现Apache Tomcat的WEB界面（变态黄猫）

4.MySQL安装：

（1）安装MysqL：

先查看当前Linux是否已安装MysqL：#rpm -qa | grep MysqL

删除原先的MysqL：#rpm -e MysqL //普通删除模式

#rpm -e --nodeps MysqL // 强力删除模式，上面命令删不干净就用这个

安装：#yum install -y MysqL-server MysqL MysqL-deve

（2）验证：

#rpm -qi MysqL-server

（3）启动MysqL：

#service MysqLd start

（4）设置开机自启动：

先查看是否为开机自启动：#chkconfig --list | grep MysqLd

MysqLd 0:off1:off2:off3:off4:off5:off6:off（可见非开机自启动）

设置为开机自启动：#chkconfig MysqLd on

重新查看：#chkconfig --list | grep MysqLd

MysqLd 0:off1:off2:on3:on4:on5:on6:off（可见已设置为开机自启动）

（5）为MysqL的root账号设置密码：

#MysqLadmin -u root password 'root' // 设置密码为root

（6）登录MysqL：

#/MysqL -u root -p

输入root密码登录

（7）创建数据库、创建表、插入数据：

创建数据库：

show databases; // 查看现有数据库，注意MysqL中每条命令最后都要加分号

create database wuyang; // 创建数据库wuyang

show databases;

use wuyang; // 切换操作wuyang为当前数据库

创建表：

show tables; // 查看现有表

create table users (userId varchar(8),userName varchar(8)); // 创建表

show tables;

插入数据：

insert into users values ('001','zhangsan');

insert into users values ('002','lisi');

select * from users; // 查询刚刚插入的数据

desc users; // 查看表结构

exit; // 登出

（8）Tomcat中创建Servlet访问MysqL：

建议先在Windows中创建，调通后再将编译后的Servlet.class和MysqL驱动器拷贝到CentOS

创建Servlet的java文件：

Eclipse创建Dynamic Web Project工程，Dynamic web module version选择2.5（选择3.0的话将不会自动生成web.xml文件）

创建Serverlet.java继承自HttpServlet

添加代码：

import java.sql.*;

doGet方法添加代码：

try
{
Class.forName("com.MysqL.jdbc.Driver");
Connection ct = DriverManager.getConnection("jdbc:MysqL://****(CentOS外网地址):3306/wuyang?useEncode=true&characterEncoding=utf-8&user=root&password=root"); // MysqL默认端口3306
// Connection ct = DriverManager.getConnection("jdbc:MysqL://127.0.0.1:3306/wuyang?useEncode=true&characterEncoding=utf-8&user=root&password=root"); // 后面把Windows的Servlet.class文件拷贝到CentOS后，把上面的这句代码中的地址改成此句中的127.0.0.1，或者相应的MysqL所在内网IP
Statement sm = ct.createStatement();
ResultSet rs = sm.executeQuery("select * from users");

while(rs.next())
{
System.out.println("username=" + rs.getString(2));
response.getWriter().append("username=" + rs.getString(2));
}
}
catch(Exception e)
{
e.printstacktrace();
response.getWriter().append(e.toString());
}

Ctrl+s保存后自动生成class文件

（9）下载MysqL连接驱动器，地址：

http://mvnrepository.com/artifact/MysqL/mysql-connector-java

下载mysql-connector-java-5.1.40-bin.jar文件（jar文件在Windows和CentOS中是通用的）

Windows放到tomcat/lib目录，CentOS同样放到tomcat/lib中

（10）重启Tomcat（过程略）：

（11）验证：

Windows浏览器访问http://****(CentOS外网地址):8080/****(对应webapps目录)/Servlet，出现：

username=zhangsanusername=lisi

5. Nginx安装：

（1）安装Nginx：

#yum -y install gcc gcc-c++ autoconf automake make // 安装gcc编译器及相关工具

#yum -y install zlib zlib-devel openssl openssl-devel pcre pcre-devel // 安装相关依赖的模块

#cd /usr/local/src

#wget http://www.Nginx.org/download/Nginx-1.2.8.tar.gz // 下载Nginx

#tar -zxvf ngingx-1.2.8.tar.gz

#cd Nginx-1.2.8

#./configure --prefix=/usr/local/Nginx // 通过编译源码的方式进行安装

//------配置完毕后如下提示-----------//
Configuration summary
+ using system PCRE library
+ OpenSSL library is not used
+ md5: using system crypto library
+ sha1: using system crypto library
+ using system zlib library

Nginx path prefix: "/usr/local/Nginx"
Nginx binary file: "/usr/local/Nginx/sbin/Nginx"
Nginx configuration prefix: "/usr/local/Nginx/conf"
Nginx configuration file: "/usr/local/Nginx/conf/Nginx.conf"
Nginx pid file: "/usr/local/Nginx/logs/Nginx.pid"
Nginx error log file: "/usr/local/Nginx/logs/error.log"
Nginx http access log file: "/usr/local/Nginx/logs/access.log"
Nginx http client request body temporary files: "client_body_temp"
Nginx http proxy temporary files: "proxy_temp"
Nginx http fastcgi temporary files: "fastcgi_temp"
Nginx http uwsgi temporary files: "uwsgi_temp"
Nginx http scgi temporary files: "scgi_temp"
//----------------------------------------//

#make

#make install

（2）启动Nginx：

#/usr/local/Nginx/sbin/Nginx -t

#/usr/local/Nginx/sbin/Nginx

检查Nginx进程，确认是否启动成功：#ps -ef | grep Nginx

（3）验证：

Windows浏览器访问http://****(CentOS外网地址):80，出现Welcome to Nginx!信息

（4）配置Nginx负载均衡：

在阿里云上申请另一个CentOS6.5的ECS实例（在Tomcat中设置不同的Servlet，或MysqL中插入不同的数据，以便后面进行验证）

设置Nginx配置文件：

#vim /usr/local/Nginx/conf/Nginx.conf

文档末尾追加：

upstream localhosts { // 默认轮询算法，权重算法下述每个server添加weight、max_fails、fail_timeout，不再累述

server 127.0.0.1:8080; // 反向代理到本机Tomcat

server ****(第二个CentOS内网地址):8080;

}

Nginx.conf文档中部找到server总结点，用#注释掉其中的整个location节点，重新添加location节点：

location / {

proxy_pass http://localhosts;

proxy_set_header X-Real-IP $remote_addr;

proxy_redirect default;

}

（5）重启Nginx：

#/usr/local/Nginx/sbin/Nginx -s reload

如果只是执行#/usr/local/Nginx/sbin/Nginx，会遇到错误：Nginx: [emerg] bind() to 0.0.0.0:80 Failed (98: Address already in use)时

#fuser -k 80/tcp // 关闭被占用的端口

#/usr/local/Nginx/sbin/Nginx//重新启动Nginx

直接运行#/usr/local/Nginx/sbin/Nginx -s reload，就不会有上述问题了

（6）验证Nginx负载均衡：

Windows浏览器连续刷新访问http://****(CentOS外网地址):80/****(对应webapps目录)/Servlet，依次交替（Nginx负载均衡的轮询算法）出现两个ECS实例的Servlet内容

关闭其中一个CentOS中的Tomcat，再刷新浏览器，发现只会访问那个还开着的CentOS的Tomcat，说明Nginx在实现负载均衡的同时，保证了高可用。

6.Redis安装：

（1）先安装tcl，否则后面无法make test：#yum install -y tcl

（2）安装Redis：

#cd ~

#wget http://download.redis.io/redis-stable.tar.gz

#tar -zxvf redis-stable.tar.gz

#cd redis-stable

#make

#make test

（3）配置Redis：

在make成功以后，会在src目录下多出一些可执行文件：redis-server，redis-cli等等。

方便期间用cp命令复制到usr目录下运行。

cp redis-server /usr/local/bin/

cp redis-cli /usr/local/bin/

然后新建目录，存放配置文件

mkdir /etc/redis

mkdir /var/redis

mkdir /var/redis/log

mkdir /var/redis/run

mkdir/var/redis/6379

在redis解压根目录中找到配置文件模板，复制到如下位置。

cp redis.conf /etc/redis/redis.conf

通过vim命令修改

daemonize yes

pidfile /var/redis/run/redis_6379.pid

logfile /var/redis/log/redis_6379.log（默认是空的，这个不太好找）

dir /var/redis/6379（默认是空的，这个也不太好找）

（4）启动redis：

#redis-server /etc/redis/redis.conf

（5）验证：

#redis-cli // 启动redis客户端

>set foo bar

>get foo

"bar"

（6）分布式访问Redis设置：

第二个CentOS上同样也要部署Redis环境，主要是要部署redis-cli（Redis客户端）

直接用第二个CentOS通过#redis-cli -h ****(第一个CentOS内网地址)-p 6379会出现错误：

Could not connect to Redis at ****:6379: Connection refused

因为Redis默认只能localhost登录，需要手动开启远程登录

在第一个CentOS修改redis-server的配置文件并重启：

#vim /etc/redis/redis.conf

找到bind localhost并使用#注释掉

这是再用第二个CentOS就能够通过#redis-cli -h ****(第一个CentOS内网地址)-p 6379访问第一个CentOS上的Redis了

（7）Tomcat中Servlet访问Redis：

先下载Redis客户端驱动jedis-2.1.0.jar，地址：

http://files.cnblogs.com/liuling/jedis-2.1.0.jar.zip

将解压后的jedis-2.1.0.jar放到目录：对应webapps下lib文件夹或对应webapps下WEB-INFO下lib文件夹中

然后在java文件添加代码：

import redis.clients.jedis.Jedis;

// 连接本地的 Redis 服务 Jedis jedis = new Jedis("127.0.0.1",6379); // 经测试只能访问本机Redis或局域网所在IP，外网无法访问！！ response.getWriter().append("Connection to server sucessfully"); // 查看服务是否运行 response.getWriter().append("Server is running: " + jedis.ping()); //获取前面设置的Key：foo response.getWriter().append(jedis.get("foo")); // 设置Key jedis.set("me","Redis tutorial"); // 获取刚刚设置的Key response.getWriter().append(jedis.get("me"));

Centos7中Docker安装 portainer、jenkins、svn 、tomcat、mysql、nginx、redis等常用容器

一、Docker简介

官网链接：https://www.docker.com

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。Docker 容器通过 Docker 镜像来创建。

二、系统要求

本次安装使用系统为：CentOS 7

三、Docker安装

1、安装Docker

Docker安装官网教程 https://docs.docker.com/engine/install/centos/

(1).设置存储库
安装yum-utils软件包（提供yum-config-manager 实用程序）并设置稳定的存储库。
sudo yum install -y yum-utils
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
(2).安装DOCKER引擎
安装最新版本的Docker Engine和容器：
sudo yum install docker-ce docker-ce-cli containerd.io

2、查看Docker版本

docker -v
docker version

3、启动Docker

systemctl start docker

4、查看Docker状态

systemctl status docker

5、重启Docker

sudo systemctl restart docker

6、停止Docker

sudo systemctl stop docker

7、设置开机自启

systemctl enable docker

8、列出所有镜像

docker images

9、删除镜像

docker rmi IMAGE_ID

10、查看所有容器

docker ps

11、启动某个容器

docker start 容器名称

12、停止某个容器

docker stop 容器名称

13、退出某个容器

exit

14、删除某个容器

docker rm 容器id

15、卸载旧版docker

sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
或者使用以下方法
列出docker安装过的相关包：
sudo yum list installed | grep docker
删除相关安装包
sudo yum -y remove docker-ce.x86_64
sudo yum -y remove docker-ce-selinux.noarch
删除相关的镜像与容器
sudo rm -rf /var/lib/docker
sudo yum remove docker docker-common docker-selinux docker-engine

16、docker run参数说明

语法: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

OPTIONS说明如下:

-a stdin: 指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项；
-d: 后台运行容器，并返回容器ID；
-i: 以交互模式运行容器，通常与 -t 同时使用；
-P: 随机端口映射，容器内部端口随机映射到主机的端口
-p: 指定端口映射，格式为：主机(宿主)端口:容器端口
-t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
--name="Nginx-lb": 为容器指定一个名称；
--dns 8.8.8.8: 指定容器使用的DNS服务器，默认和宿主一致；
--dns-search example.com: 指定容器DNS搜索域名，默认和宿主一致；
-h "mars": 指定容器的hostname；
-e username="ritchie": 设置环境变量；
--env-file=[]: 从指定文件读入环境变量；
--cpuset="0-2" or --cpuset="0,1,2": 绑定容器到指定cpu运行；
-m :设置容器使用内存最大值；
--net="bridge": 指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型；
--link=[]: 添加链接到另一个容器；
--expose=[]: 开放一个端口或一组端口；
--volume , -v: 绑定一个卷

四、Docker获取portainer镜像,安装 portainer容器

portainer为docker的可视化页面,安装后可以打开,进行可视化操作.

1、搜索portainer镜像

docker search portainer

2、拉取portainer镜像

docker pull portainer/portainer:latest

3、安装并启动一个portainer容器

docker run -d  --name portainer  -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock --restart always --privileged=true portainer/portainer

4、通过浏览器输入http://ip:9000即可访问portainer,进入可视化页面,操作对应的镜像(Images)和容器(Containers),如下图所示:

五、Docker获取jenkins镜像,安装 jenkins容器

1、搜索jenkins镜像

docker search jenkins

2、拉取jenkins镜像

docker pull jenkins/jenkins:lts

3、创建一个jenkins目录

mkdir /home/jenkins_home

4、启动一个jenkins容器并绑定jdk路径和maven路径

docker run --name jenkins\
-u root\
-d\
-p 8061:8080\
-p 50000:50000\
-v /usr/bin/docker:/usr/bin/docker:Z \
-v /var/run/docker.sock:/var/run/docker.sock:Z \
-v /etc/sysconfig/docker:/etc/sysconfig/docker:Z \
-v /opt/software/jdk1.8.0_201:/opt/software/jdk1.8.0_201:Z \
-v /opt/software/apache-maven-3.6.3:/opt/software/apache-maven-3.6.3:Z \
-v /opt/software/maven-repo:/opt/software/maven-repo:Z \
-v /home/jenkins_home:/var/jenkins_home:Z \
--restart=always \
--privileged=true \
jenkins/jenkins:lts

5、查看jenkins服务

docker ps | grep jenkins

6、进入jenkins容器内部

docker exec -it jenkins_01 bash

六、Docker获取svn镜像,安装 svn容器

1、搜索svn镜像

docker search svn

2、拉取svn镜像

docker pull garethflowers/svn-server:latest

3、创建svn容器

docker run --privileged=true  --restart always --name svn -d -v /root/dockers/svn:/var/opt/svn -p 3690:3690 garethflowers/svn-server

4、进入svn容器

docker exec -it svn /bin/sh

5、创建仓库

[root@local /]# docker exec -it svn /bin/sh
/var/opt/svn # svnadmin create project

6、svn位置

/root/dockers/svn/project

七、Docker获取tomcat镜像,安装 tomcat容器

1、搜索tomcat镜像

docker search tomcat

2、拉取tomcat镜像

docker pull tomcat:7-jre7

3、创建tomcat容器

docker run -di --name jenkins_tomcat -p 9000:8080 -v /usr/local/myhtml:/usr/local/tomcat/webapps --privileged=true tomcat:7-jre7

4、进入tomcat容器

docker exec -it jenkins_tomcat /bin/bash

5 、将tomcat中webapps.dist复制到宿主机/usr/local/myhtml中并改名为webapps.

cd /usr/local/myhtml
docker cp jenkins_tomcat:/usr/local/tomcat/webapps.dist webapps

八、Docker获取MysqL镜像,安装 MysqL容器

1、搜索MysqL镜像

docker search MysqL

2、拉取MysqL镜像

docker pull MysqL:5.7

3、创建MysqL容器并指定时区

docker run -d --name MysqL57 \
-p 3306:3306 \
-v /home/MysqL57/conf:/etc/MysqL/MysqL.conf.d \
-v /home/MysqL57/logs:/logs \
-v /home/MysqL57/data:/var/lib/MysqL \
-e MysqL_ROOT_PASSWORD=dzp_dream \
-e TZ=Asia/Shanghai \
--restart always \
MysqL:5.7 \
--lower_case_table_names=1 \
--default-time_zone='+8:00'

注: -e TZ=Asia/Shanghai 和 --default-time_zone='+8:00' 设置时区

--lower_case_table_names=1 设置不区分大小写

4、进入MysqL容器

docker exec -it MysqL57 /bin/bash

5、进入MysqL

MysqL -u root -p

九、Docker获取Nginx镜像,安装 Nginx容器

1、搜索Nginx镜像

docker search Nginx

2、拉取Nginx镜像

docker pull Nginx:latest

3、创建Nginx容器

docker run -d --name newNginx \
-p 80:80 \
-v /Nginx/html:/usr/share/Nginx/html:ro \
-v /Nginx/conf/conf.d:/etc/Nginx/conf.d \
-v /Nginx/logs:/var/log/Nginx \
Nginx

4、进入Nginx容器

docker exec -it newNginx /bin/bash

十、Docker获取redis镜像,安装 redis容器

1、搜索redis镜像

docker search redis

2、拉取redis镜像

docker pull redis:latest

3、创建redis容器，并设置密码

docker run -d --name myredis -p 6379:6379 redis:latest --requirepass "dzp_dream"

4、进入redis容器

docker exec -it myredis /bin/bash

十一、Docker获取zookeeper镜像,安装 zookeeper容器

1、搜索zookeeper镜像

docker search zookeeper

2、拉取zookeeper镜像

docker pull docker.io/wurstmeister/zookeeper

3、创建zookeeper容器

docker run -d --name zookeeper -p 2181:2181 -t wurstmeister/zookeeper

4、进入zookeeper容器

docker exec -it zookeeper /bin/bash

十二、Docker获取kafka镜像,安装 kafka 容器

1、搜索kafka镜像

docker search kafka

2、拉取kafka镜像

docker pull docker.io/wurstmeister/kafka:2.12-2.1.0

3、创建kafka容器

docker run -d --name kafka -p 9092:9092 -e KAFKA_broKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=172.17.0.5:2181 -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.189.130:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 -t wurstmeister/kafka:2.12-2.1.0

4、进入kafka容器

docker exec -it kafka /bin/bash

十三、Docker获取postgresql+postgis镜像,安装 postgresql+postgis容器

1、搜索postgresql+postgis镜像

docker search postgresql

2、拉取postgresql+postgis镜像

docker pull kartoza/postgis:11.0-2.5

3、创建postgresql+postgis容器

docker run -t --name postgresql --restart always  -e POSTGRES_USER='postgres' -e POSTGRES_PASSWORD=dzp_dream -e ALLOW_IP_RANGE=0.0.0.0/0 -p 5432:5432 -d kartoza/postgis:11.0-2.5

4、进入postgresql+postgis容器

docker exec -it postgresql /bin/bash

十四、Docker获取MinIO镜像,安装 MinIO容器

1、搜索MinIO镜像

docker search minio

2、拉取MinIO镜像

docker pull minio/minio

3、创建MinIO容器

docker run -d -p 9001:9000 --name minio \
-e "MINIO_ACCESS_KEY=minio" \
-e "MINIO_SECRET_KEY=dzp_dream" \
-v /opt/app/cloud/minio/data:/data \
-v /opt/app/cloud/minio/config:/root/.minio \
minio/minio server /data

4、进入MinIO容器

docker exec -it minio /bin/bash

5、安装MinIO集群,请参考 https://blog.csdn.net/DZP_dream/article/details/110876214

十五、Docker获取gitlab镜像,安装 gitlab容器

1、搜索gitlab镜像

docker search gitlab

2、拉取gitlab镜像

docker pull gitlab/gitlab-ce

3、创建gitlab容器 ( 如果系统开启SElinux时,需要在映射卷的命令后加上":Z" )

docker run -d \
-p 8443:443 \
-p 80:80 \
-p 222:22 \
--name gitlab \
--restart always \
--hostname 192.168.189.130 \
-v /home/gitlab/config:/etc/gitlab:Z \
-v /home/gitlab/logs:/var/log/gitlab:Z \
-v /home/gitlab/data:/var/opt/gitlab:Z \
gitlab/gitlab-ce

4、进入gitlab容器

docker exec -it gitlab /bin/bash

5、访问gitlab

通过浏览器 ip 直接访问,(端口号默认80)

十六、Docker获取Nacos镜像,安装 Nacos容器

1、搜索Nacos镜像

docker search nacos/nacos-server

2、拉取Nacos镜像

docker pull nacos/nacos-server

3、创建Nacos容器

docker run --env MODE=standalone --name nacos -d -p 8848:8848 nacos/nacos-server

4、进入Nacos容器

docker exec -it nacos /bin/bash

5、访问:通过 ip:8848/nacos 访问，登录密码默认nacos/nacos

十七、Docker获取elasticsearch镜像,安装 elasticsearch容器

1、搜索elasticsearch镜像

docker search elasticsearch

2、拉取elasticsearch镜像

docker pull elasticsearch

3、创建elasticsearch容器

docker run -e ES_JAVA_OPTS="-xms256m -Xmx256m" -d -p 9200:9200 -p 9300:9300 --name ES01 docker.io/elasticsearch

4、进入elasticsearch容器

docker exec -it elasticsearch /bin/bash

5、访问:通过 http://ip:9200/ 访问，出现下图安装成功

十八、Docker获取RabbitMQ镜像,安装 RabbitMQ容器

1、搜索RabbitMQ镜像

docker search rabbitmq:management

2、拉取RabbitMQ镜像

docker pull rabbitmq:management

3、创建RabbitMQ容器

docker run -d --hostname my-rabbit --name rabbit -p 15672:15672 -p 5672:5672 docker.io/rabbitmq:management

4、进入RabbitMQ容器

docker exec -it rabbit /bin/bash

5、访问:通过 http://ip:15672/ 访问，出现下图安装成功

十九、Docker获取私有仓库registry镜像,安装 registry容器

1、搜索registry镜像

docker search registry

2、拉取registry镜像

docker pull registry

3、创建registry容器

docker run --name=registry -p 5000:5000 -di registry

4、进入registry容器

docker exec -it registry /bin/bash

5、修改配置文件

 vim /etc/docker/daemon.json

添加如下内容：

{
"insecure-registries":["192.168.1.175:5000"]
}

6、使其生效并重启docker

sudo systemctl daemon-reload
sudo systemctl restart docker

7、访问:通过 http://ip:5000/v2/_catalog 访问，出现下图安装成功

二十、Docker获取Memcached镜像,安装 Memcached容器

1、搜索Memcached镜像

docker search memcached

2、拉取Memcached镜像

docker pull memcached

3、创建Memcached容器

docker run -d --name mymemcache -p 11211:11211  memcached

4、Memcached相关操作

telnet 127.0.0.1 11211
set test 0 900 9
memcached
STORED
get test
VALUE test 0 9
memcached
END
quit

二十一、Docker获取MongoDB镜像,安装MongoDB容器

1、搜索MongoDB镜像

docker search mongo

2、拉取MongoDB镜像

docker pull mongo:latest

3、创建MongoDB容器

docker run -itd --name mymongo -p 27017:27017 mongo --auth

4、进入MongoDB容器

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

二十二、查看所有的容器

二十三、其他容器安装

其他容器安装,与以上步骤大同小异。

敬请批评指正

CentOS7中Docker安装tomcat、redis、mysql 8.0

一、CentOS7安装Docker

1、检查内核版本，必须是3.10及以上

[root@iz2zeizzt8ihoeoyopzzyhz ~]# uname -r
3.10.0-514.26.2.el7.x86_64

2、使用 yum install docker进行安装

[root@iz2zeizzt8ihoeoyopzzyhz ~]#yum install docker

下载确认后出现Complete!则表示成功

3、启动docker

[root@iz2zeizzt8ihoeoyopzzyhz ~]# systemctl start docker

4、查看docker版本

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker -v
Docker version 1.13.1, build 94f4240/1.13.1

5、开机启动docker

[root@iz2zeizzt8ihoeoyopzzyhz ~]# systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

二、Docker安装tomcat并部署war工程

1、拉取tomcat镜像

可以在https://hub.docker.com/r/library/tomcat/ 进行搜索(不指定版本默认安装最新版)

2、安装tomcat

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker pull tomcat

3、查看所有镜像

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
docker.io/tomcat    latest              56219f61066f        51 minutes ago      463 MB

4、启动tomcat

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker run --name tomcat8080 -d -p 8080:8080 tomcat 
a3d4f36dca9865619b48c325c06f5147c92230e369051a60e82fb461eb6f1e20

--name :给容器命名

-d : 后台运行

-p:端口映射

5、查看运行的tomcat

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
a3d4f36dca98        tomcat              "catalina.sh run"   5 seconds ago       Up 4 seconds        0.0.0.0:8080->8080/tcp   tomcat8080

然后在浏览器输入 ip:8080可访问默认的tomcat界面

6、部署war工程

首先上传war包到服务器，比如我上传到/home路径下

[root@iz2zeizzt8ihoeoyopzzyhz ~]# ll
total 212532
-rw-r--r-- 1 root root  17231526 Nov 22  2017 admin-controller.war

7、将war包复制到docker容器的tomcat中

可以参考以下两篇博文：

https://blog.csdn.net/qq_32351227/article/details/78673591

https://blog.csdn.net/leafage_m/article/details/72082011

具体我的操作如下：

获取长长的那个ID(tomcat8080是我启动的tomcat起的名字)

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker inspect -f ''{{.Id}}'' tomcat8080
a3d4f36dca9865619b48c325c06f5147c92230e369051a60e82fb461eb6f1e20

查看容器中tomcat地址(a3d4f36dca98是tomcat的id)

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker  exec -it  a3d4f36dca98   /bin/bash
root@a3d4f36dca98:/usr/local/tomcat#

将tomcat中webapps下的默认文件都删除

root@a3d4f36dca98:/usr/local/tomcat# cd webapps/
root@a3d4f36dca98:/usr/local/tomcat/webapps# 
root@a3d4f36dca98:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager   ----这些文件都删掉
root@a3d4f36dca98:/usr/local/tomcat/webapps#

将war包cp进tomcat的webapps路径下(docker cp 本地文件路径 ID全称:容器路径)

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker cp admin-controller.war a3d4f36dca9865619b48c325c06f5147c92230e369051a60e82fb461eb6f1e20:/usr/local/tomcat/webapps/admin-controller.war

restart下就能访问部署的项目了

三、Docker安装redis

1、拉取redis镜像(推荐使用Docker中国的镜像加速)

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker pull registry.docker-cn.com/library/redis

2.启动redis

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker run -d -p 6379:6379 --name redis6379 bfcb1f6df2db

然后就可以使用redis客户端工具RedisDesktopManage本地进行操作了

四、Docker安装mysql 8

1、拉取mysql镜像

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker pull mysql

2.启动mysql

[root@iz2zeizzt8ihoeoyopzzyhz ~]# docker run -p 3309:3306 --name mysql3309 -e MYSQL_ROOT_PASSWORD=root -d mysql --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

连接客户端会出现问题：本地连接不上

解决：

#Docker-mysql8.0客户端无法连接
 
进入容器bash并进入mysql命令行
docker exec -it mysql3306 bash
root@eb3dbfb0958f:/# mysql -uroot -p  
Enter password:   
Welcome to the MySQL monitor.  Commands end with ; or \g.  
…   
mysql>
//使用mysql数据库
mysql>use mysql
   
//修改数据库
mysql> ALTER USER ''root''@''%'' IDENTIFIED WITH mysql_native_password BY ''root'';
 
//重新修改密码后可连接成功
mysql> alter  user ''root''@''%'' identified by ''root'';
 
//刷新数据库
mysql> flush privileges;

然后本地就能连接成功了。

CentOS7中Docker应用部署（MySQL、Tomcat、Nginx、Redis）

目标

Docker应用部署

环境
CentOS7 #宿主机
Docke #开源应用容器引擎

应用部署
1. Redis部署
1.1 拉取镜像

# 拉取redis镜像
docker pull redis

1.2 创建容器

# 创建redis容器
# 默认net网络模式 
docker run -di --name=myredis -p 6379:6379 redis
# 指定net网络模式
docker run -di --net="host" --name=myredis -p 6379:6379 redis

1.3 操作redis容器

# 进入redis容器
docker exec -it myredis /bin/bash
# 进入redis安装目录
cd /usr/local/bin
# 连接redis
./redis-cli

1.4 测试结果

1.5 测试结果

2. MySQL部署
2.1 拉取镜像

# 拉取MySQL 5.7镜像
docker pull centos/mysql-57-centos7

2.2 创建容器

# 创建mysql5.7容器
# 默认net网络模式 
docker run -di --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root centos/mysql-
57-centos7
# 指定net网络模式
docker run -di --net="host" --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root centos/mysql-57-centos7

docker run -di --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql
-p 代表端口映射，格式为宿主机映射端口:容器运行端口
-e 代表添加环境变量 MYSQL_ROOT_PASSWORD 是root用户的远程登陆密码（如果是在容器中使用root登录的话，
那么其密码为空）

2.3 操作容器MySQL

# 进入容器
docker exec -it mysql5.7 /bin/bash
# 登录容器里面的mysql
mysql -u root -p

2.4 远程登录MySQL

# 查看ip；如果以后要内部连接该mysql，如其他容器中要连接mysql容器的mysql的时候，可以使用如下命令查看Ip
docker inspect mysql5.7

3. Nginx部署
3.1 拉取镜像

# 拉取nginx镜像
docker pull nginx

3.2 创建容器

# 创建nginx容器
# 默认net网络模式 
docker run -di --name=mynginx -p 80:80 nginx

# 指定net网络模式
docker run -di --net="host" --name=mynginx -p 80:80 nginx

3.3 测试结果
# 1-宿主机访问地址：http://192.168.157.110/

# 2-docker访问地址：http://172.17.0.1

4. Tomcat部署
4.1 拉取镜像

# 拉取tomcat镜像
docker pull tomcat

5.2 创建容器

# 方式一
# 指定net网络模式
docker run -di --net="host" --name=tomcat -p 8080:8080 tomcat

# 方式二 挂载方式
# 创建tomcat容器;并挂载了webapps目录
docker run -di --name=mytomcat -p 8080:8080 -v
/usr/local/tomcat/webapps:/usr/local/tomcat/webapps tomcat
# 如果出现 WARNING: IPv4 forwarding is disabled. Networking will not work.
#执行如下操作
# 1、编辑 sysctl.conf
vi /etc/sysctl.conf
# 2、在上述打开的文件中后面添加
net.ipv4.ip_forward=1
# 3、重启network
systemctl restart network

6.3 测试效果
# 1-宿主机访问地址：http://192.168.157.110:8080/

# 2-docker访问地址：http://172.17.0.1:8080/

我们今天的关于mysql|tomcat|nginx|redis 在 docker 中的部署和docker部署mysql的好处的分享就到这里，谢谢您的阅读，如果想了解更多关于CentOS6.5+JDK+Tomcat+Mysql+Nginx负载均衡+Redis环境部署、Centos7中Docker安装 portainer、jenkins、svn 、tomcat、mysql、nginx、redis等常用容器、CentOS7中Docker安装tomcat、redis、mysql 8.0、CentOS7中Docker应用部署（MySQL、Tomcat、Nginx、Redis）的相关信息，可以在本站进行搜索。

本文标签：