Dockerfile构建镜像（SSH、Systemctl、nginx、tomcat 、mysql、）

目录

构建SSH镜像

构建Systemctl镜像

构建nginx镜像

构建Tomcat镜像

构建MySQL镜像

---

构建SSH镜像

切换到目录 /opt/sshd：

cd /opt/sshd

        这是为了进入一个特定的目录，后续的操作将在这个目录下进行。

创建一个 Dockerfile 并使用 Vim 编辑它：

vim Dockerfile

        在这一步，你使用Vim编辑器创建或编辑名为Dockerfile的文件。Vim是一个文本编辑器，你可以使用其他编辑器替代。

在 Dockerfile 中添加以下内容，这些内容定义了构建Docker镜像的步骤：

# 使用的基础镜像
FROM centos:7

# 作者信息
MAINTAINER this is ssh image 

# 安装软件包和设置SSH服务
RUN yum -y update
RUN yum -y install openssh* net-tools lsof telnet passwd
RUN echo '123456' | passwd --stdin root
RUN sed -i 's/UsePAM yes/UsePAM no/g' /etc/ssh/sshd_config
RUN sed -ri '/^session\s+required\s+pam_loginuid.so/ s/^/#/' /etc/pam.d/sshd
RUN ssh-keygen -t rsa -A
RUN mkdir -p /root/.ssh && chown root.root /root && chmod 700 /root/.ssh

# 暴露SSH服务端口
EXPOSE 22

# 启动SSH服务
CMD ["/usr/sbin/sshd", "-D"]

        保存并退出 Vim。

构建镜像：

docker build -t sshd:centos .

        这一步使用Docker命令构建一个新的镜像，-t参数指定了镜像的名称和标签。

启动容器并修改 root 密码：

docker run -d -P sshd:centos
docker ps -a

        这一步启动了一个新的Docker容器，-d参数表示在后台运行，-P参数会随机映射容器内SSH服务的端口到主机上。使用docker ps -a查看容器的详细信息。

使用 SSH 连接到容器：

ssh localhost -p 11451

        最后，这一步使用SSH客户端连接到运行的容器，其中-p参数指定了映射后的端口号，而连接时使用密码 123456 进行身份验证。确保你的本地主机上已安装SSH客户端。

构建Systemctl镜像

用于创建一个基于CentOS的Docker镜像，该镜像中包含了systemd和ssh服务。

创建目录和进入目录：

mkdir /opt/systemctl
cd /opt/systemctl

在 /opt/systemctl 目录下创建一个新的Docker镜像。

创建 Dockerfile 并编辑它：

vim Dockerfile

        在这一步，使用Vim编辑器创建或编辑名为 Dockerfile 的文件。

在 Dockerfile 中添加以下内容，用于构建包含 systemd 和 ssh 服务的镜像：

FROM sshd:centos
MAINTAINER this is systemctl image 
ENV container docker

# 删除不必要的 systemd 文件
RUN (cd /lib/systemd/system/sysinit.target.wants/; for i in *; do [ $i == systemd-tmpfiles-setup.service ] || rm -f $i; done); \
rm -f /lib/systemd/system/multi-user.target.wants/*; \
rm -f /etc/systemd/system/*.wants/*; \
rm -f /lib/systemd/system/local-fs.target.wants/*; \
rm -f /lib/systemd/system/sockets.target.wants/*udev*; \
rm -f /lib/systemd/system/sockets.target.wants/*initctl*; \
rm -f /lib/systemd/system/basic.target.wants/*;\
rm -f /lib/systemd/system/anaconda.target.wants/*;

VOLUME [ "/sys/fs/cgroup" ]
#CMD ["/usr/sbin/init"]

保存并退出 Vim。

构建镜像：

docker build -t systemd:centos .

使用Docker命令构建一个新的镜像，-t参数指定了镜像的名称和标签。

启动容器并挂载目录进行初始化：

docker run --privileged -d -P -v /sys/fs/cgroup:/sys/fs/cgroup:ro systemd:centos /sbin/init

        这一步启动了一个新的Docker容器，使用 --privileged 参数使得容器内的root用户拥有真正的root权限。-v参数用于将宿主机的 /sys/fs/cgroup 目录挂载到容器内，并进行了初始化。

查看容器信息：

docker ps -a

使用该命令查看容器的详细信息，包括容器的ID等。

进入容器并检查 SSH 服务状态：

docker exec -it  bash
systemctl status sshd

使用 docker exec 命令进入容器，并在容器内执行 systemctl status sshd 来检查 SSH 服务的状态。

        这一系列命令主要用于创建包含 systemd 和 ssh 服务的 Docker 镜像，并在容器内进行一些初始化。请替换 为实际的容器ID。请注意，使用 systemd 在容器内运行时，一些操作可能需要额外的配置和权限。

两种启动方法

docker run --privileged -it -P -v /sys/fs/cgroup:/sys/fs/cgroup:ro systemd:centos /sbin/init &

• -it: 分配一个交互式终端，允许用户与容器进行交互。这使得在终端内执行 systemd:centos /sbin/init。

• &: 在命令的末尾表示将该命令放到后台运行。

  这个命令的效果是以交互方式启动容器，并在容器内运行 systemd 的初始化进程。由于使用了 -it，用户可以在启动的容器中进行交互。& 将容器放到后台运行，但在这种情况下，可能无法直接看到容器的输出，因为终端会返回到主机。

docker run --privileged -d -P -v /sys/fs/cgroup:/sys/fs/cgroup:ro systemd:centos /sbin/init

• -d: 在后台运行容器，即使没有交互终端。

• 没有使用 -it，因此容器在后台运行时不会分配交互式终端。

  这个命令的效果是以后台方式启动容器，容器在后台运行且没有交互式终端。可以通过 docker logs 来查看容器的输出。

总的来说，第一个命令是以交互方式启动容器，适合需要手动交互的场景，而第二个命令是在后台运行容器，适合无需用户干预的场景。具体选择取决于你的需求和使用场景。

构建nginx镜像

构建基于CentOS 7的Nginx Docker镜像的Dockerfile文件

创建目录并复制Nginx压缩包到指定目录：

mkdir /opt/nginx
cd /opt/nginx/
cp /opt/nginx-1.12.0.tar.gz /opt/nginx

进入Nginx目录并创建Dockerfile文件：

cd /opt/nginx/
vim Dockerfile

Dockerfile内容：

#基于基础镜像
FROM centos:7
#用户信息
MAINTAINER this is nginx image 
#添加环境包
RUN yum -y update
RUN yum -y install pcre-devel zlib-devel gcc gcc-c++ make
RUN useradd -M -s /sbin/nologin nginx
#上传nginx软件压缩包，并解压
ADD nginx-1.12.0.tar.gz /opt/
#指定工作目录
WORKDIR /opt/nginx-1.12.0
RUN ./configure \
--prefix=/usr/local/nginx \
--user=nginx \
--group=nginx \
--with-http_stub_status_module && make && make install
ENV PATH /usr/local/nginx/sbin:$PATH
#指定http和https端口
EXPOSE 80
EXPOSE 443
RUN echo "daemon off;" >> /usr/local/nginx/conf/nginx.conf   #关闭 nginx 在后台运行
#添加宿主机中run.sh到容器中
ADD run.sh /run.sh
RUN chmod 755 /run.sh
CMD ["/run.sh"]

编辑run.sh脚本文件：

vim run.sh

run.sh内容：

#!/bin/bash
/usr/local/nginx/sbin/nginx

构建Docker镜像：

docker build -t nginx:centos .

运行Docker容器：

docker run -d -P nginx:centos

查看容器运行状态：

docker ps -a

在示例中，容器的端口映射为0.0.0.0:32799->80/tcp和0.0.0.0:32798->443/tcp。

访问Nginx服务： 打开浏览器访问 http://192.168.31.31:32799（具体IP和端口根据你的环境配置而定）。

构建Tomcat镜像

创建一个基于CentOS 7的Docker容器，其中包含了Tomcat和Java环境

创建目录并进入：

mkdir /opt/tomcat
cd /opt/tomcat

在/opt目录下创建一个名为tomcat的目录，并进入该目录。

复制文件：

cp /opt/jdk-8u91-linux-x64.tar.gz /opt/tomcat
cp /opt/apache-tomcat-8.5.16.tar.gz /opt/tomcat

将jdk-8u91-linux-x64.tar.gz和apache-tomcat-8.5.16.tar.gz复制到/opt/tomcat目录下。

创建Dockerfile并编辑：

vim Dockerfile

创建一个名为Dockerfile的文件并编辑。

Dockerfile内容：

FROM centos:7
MAINTAINER this is tomcat image 

ADD jdk-8u91-linux-x64.tar.gz /usr/local/
WORKDIR /usr/local/
RUN mv jdk1.8.0_91 /usr/local/java
ENV JAVA_HOME /usr/local/java
ENV JRE_HOME ${JAVA_HOME}/jre
ENV CLASSPATH .:${JAVA_HOME}/lib:${JRE_HOME}/lib
ENV PATH $JAVA_HOME/bin:$PATH

ADD apache-tomcat-8.5.16.tar.gz /usr/local/
WORKDIR /usr/local/
RUN mv apache-tomcat-8.5.16 /usr/local/tomcat

EXPOSE 8080
#CMD ["/usr/local/tomcat/bin/catalina.sh","run"]
ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh","run"]

Dockerfile定义了构建Docker镜像的步骤。它基于CentOS 7，安装了Java和Tomcat，并设置了相应的环境变量。

构建Docker镜像：

docker build -t tomcat:centos .

使用Dockerfile构建一个名为tomcat:centos的Docker镜像。

运行Docker容器：

docker run -d --name tomcat01 -p 1216:8080 tomcat:centos

在后台运行名为tomcat01的Docker容器，将容器的8080端口映射到主机的1216端口。

访问Tomcat应用： 打开浏览器并访问：http://192.168.41.31:1216

构建MySQL镜像

创建并进入 /opt/mysqld 目录。

mkdir /opt/mysqld
cd /opt/mysqld

使用 vim 编辑器创建名为 Dockerfile 的文件。

vim Dockerfile

Dockerfile 内容：

FROM centos:7
MAINTAINER this is mysql image 
RUN yum -y install gcc gcc-c++ ncurses ncurses-devel bison cmake make
RUN useradd -M -s /sbin/nologin  mysql
ADD mysql-boost-5.7.20.tar.gz /usr/local/src/
WORKDIR /usr/local/src/mysql-5.7.20/
RUN cmake \
-DCMAKE_INSTALL_PREFIX=/usr/local/mysql \
-DMYSQL_UNIX_ADDR=/usr/local/mysql/mysql.sock \
-DSYSCONFDIR=/etc \
-DSYSTEMD_PID_DIR=/usr/local/mysql \
-DDEFAULT_CHARSET=utf8  \
-DDEFAULT_COLLATION=utf8_general_ci \
-DWITH_INNOBASE_STORAGE_ENGINE=1 \
-DWITH_ARCHIVE_STORAGE_ENGINE=1 \
-DWITH_BLACKHOLE_STORAGE_ENGINE=1 \
-DWITH_PERFSCHEMA_STORAGE_ENGINE=1 \
-DMYSQL_DATADIR=/usr/local/mysql/data \
-DWITH_BOOST=boost \
-DWITH_SYSTEMD=1 && make && make install
RUN chown -R mysql:mysql /usr/local/mysql/
RUN rm -rf /etc/my.cnf
ADD my.cnf /etc/
RUN chown mysql:mysql /etc/my.cnf
ENV PATH=/usr/local/mysql/bin:/usr/local/mysql/lib:$PATH
WORKDIR /usr/local/mysql/
RUN bin/mysqld \
--initialize-insecure \
--user=mysql \
--basedir=/usr/local/mysql \
--datadir=/usr/local/mysql/data
RUN cp /usr/local/mysql/usr/lib/systemd/system/mysqld.service /usr/lib/systemd/system/
EXPOSE 3306
ADD run.sh /usr/local/src
RUN chmod 755 /usr/local/src/run.sh
RUN sh /usr/local/src/run.sh
#CMD ["/usr/sbin/init"]

• FROM centos:7：基于 CentOS 7 镜像构建。

• MAINTAINER：设置镜像的作者信息。

• 安装依赖包：

RUN yum -y install gcc gcc-c++ ncurses ncurses-devel bison cmake make

• 创建 MySQL 用户：

RUN useradd -M -s /sbin/nologin mysql

• 将 MySQL 源代码压缩包解压到 /usr/local/src/ 目录：

ADD mysql-boost-5.7.20.tar.gz /usr/local/src/

• 进入 MySQL 源代码目录：

WORKDIR /usr/local/src/mysql-5.7.20/

• 使用 cmake 进行 MySQL 的配置和编译：

RUN cmake \
  -DCMAKE_INSTALL_PREFIX=/usr/local/mysql \
  ...
  && make && make install

• 设置文件权限和清理不需要的文件：

RUN chown -R mysql:mysql /usr/local/mysql/
RUN rm -rf /etc/my.cnf

• 添加自定义的 MySQL 配置文件并设置文件权限：

ADD my.cnf /etc/
RUN chown mysql:mysql /etc/my.cnf

• 设置环境变量 PATH：

ENV PATH=/usr/local/mysql/bin:/usr/local/mysql/lib:$PATH

• 进入 MySQL 安装目录：

WORKDIR /usr/local/mysql/

• 初始化 MySQL 数据库：

RUN bin/mysqld \
  --initialize-insecure \
  --user=mysql \
  --basedir=/usr/local/mysql \
  --datadir=/usr/local/mysql/data

• 将 systemd 的 MySQL 服务配置文件复制到正确的目录：

RUN cp /usr/local/mysql/usr/lib/systemd/system/mysqld.service /usr/lib/systemd/system/

• 暴露 MySQL 的默认端口：

EXPOSE 3306

• 添加运行脚本和设置权限：

ADD run.sh /usr/local/src
RUN chmod 755 /usr/local/src/run.sh
RUN sh /usr/local/src/run.sh

• 注释的 #CMD ["/usr/sbin/init"] 行，该行是被注释掉的，可能是为了在容器内运行 systemd 的初始化进程。

配置MySQL配置文件（my.cnf）

vim my.cnf
[client]
port = 3306
default-character-set=utf8
socket = /usr/local/mysql/mysql.sock

[mysql]
port = 3306
default-character-set=utf8
socket = /usr/local/mysql/mysql.sock

[mysqld]
user = mysql
basedir = /usr/local/mysql
datadir = /usr/local/mysql/data
port = 3306
character_set_server=utf8
pid-file = /usr/local/mysql/mysqld.pid
socket = /usr/local/mysql/mysql.sock
server-id = 1

sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_AUTO_VALUE_ON_ZERO,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,PIPES_AS_CONCAT,ANSI_QUOTES

[client]：

• port = 3306: 指定客户端连接 MySQL 服务器的端口号为 3306。

• default-character-set=utf8: 设置客户端默认字符集为 UTF-8。

• socket = /usr/local/mysql/mysql.sock: 指定客户端连接 MySQL 服务器时使用的套接字文件路径。

[mysql]：

• port = 3306: 指定 MySQL 客户端程序连接 MySQL 服务器的端口号为 3306。

• default-character-set=utf8: 设置 MySQL 客户端程序默认字符集为 UTF-8。

• socket = /usr/local/mysql/mysql.sock: 指定 MySQL 客户端程序连接 MySQL 服务器时使用的套接字文件路径。

[mysqld]：

• user = mysql: 指定 MySQL 服务器运行的用户为 "mysql"。

• basedir = /usr/local/mysql: 指定 MySQL 安装的基础目录。

• datadir = /usr/local/mysql/data: 指定 MySQL 存储数据文件的目录。

• port = 3306: 指定 MySQL 服务器监听的端口号为 3306。

• character_set_server=utf8: 设置 MySQL 服务器的字符集为 UTF-8。

• pid-file = /usr/local/mysql/mysqld.pid: 指定保存 MySQL 服务器进程ID的文件路径。

• socket = /usr/local/mysql/mysql.sock: 指定 MySQL 服务器的套接字文件路径。

• server-id = 1: 设置 MySQL 服务器的唯一标识 ID 为 1。

sql_mode：

• NO_ENGINE_SUBSTITUTION: 不替换存储引擎。

• STRICT_TRANS_TABLES: 严格遵守事务处理规则。

• NO_AUTO_CREATE_USER: 不自动创建用户。

• NO_AUTO_VALUE_ON_ZERO: 在插入时，如果列的值为零，则不自动增加。

• NO_ZERO_IN_DATE: 日期中不允许使用零值。

• NO_ZERO_DATE: 不允许日期列的零值。

• ERROR_FOR_DIVISION_BY_ZERO: 发生除零错误时产生错误。

• PIPES_AS_CONCAT: 将管道符号（|）视为字符串连接运算符而非逻辑运算符。

• ANSI_QUOTES: 启用 ANSI_QUOTES 模式，双引号用于引用标识符。

编写脚本用于启动 MySQL 服务器的 Docker 容器，并进行相关初始化和权限配置。

启动 MySQL 服务器的 Docker 容器：

docker run --name=mysql_server -d -P --privileged mysql:centos /usr/sbin/init

• --name=mysql_server: 指定容器的名称为 "mysql_server"。

• -d: 在后台运行容器。

• -P: 将容器内部使用的网络端口映射到随机的主机端口。

• --privileged: 赋予容器所有的 Linux 的权限。

• mysql:centos: 使用名为 "mysql:centos" 的 Docker 镜像。

• /usr/sbin/init: 启动容器的初始化进程。

授权远程连接 MySQL：

docker exec -it f9a4d8f6c65f /bin/bash

• 进入容器内部的 Bash 环境。

mysql -u root -p
grant all privileges on *.* to 'root'@'%' identified by '123456';
grant all privileges on *.* to 'root'@'localhost' identified by '123456';
flush privileges;

• 登录 MySQL 服务器，使用 root 用户，并输入密码。

• 授权 root 用户允许从任何主机连接，并设置密码为 '123456'。

• 同样，授权 root 用户允许从本地连接，并设置密码为 '123456'。

• 刷新权限以使更改生效。

在客户端连接 MySQL 容器：

mysql -h 192.168.41.31 -u root -P 49153 -123456

• 连接到 MySQL 服务器的容器，指定主机地址为 192.168.41.31，用户名为 root，端口为 49153，密码为 '123456'。

注意：确保防火墙或网络配置允许从客户端到容器的连接，同时保护数据库密码的安全性。