docker部署服务案例

m0_75010543

936人浏览 · 2025-11-16 00:04:42

m0_75010543 · 2025-11-16 00:04:42 发布

编排部署wordpress

在master节点上编写/root/wordpress/docker-compose.yaml文件，具体要求如下：
（1）容器名称：wordpress；镜像：wordpress:latest；端口映射：82:80；
（2）容器名称：mysql；镜像：mysql:5.6；
（3）MySQLroot用户密码：123456；
（4）创建数据库wordpress。
完成后编排部署WordPress。

version: '3'
services:
  mysql:
    image: mysql:5.6
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: wordpress

  wordpress:
    depends_on:
      - mysql
    image: wordpress:latest
    ports:
      - 82:80
    links:
      - mysql:mysql
    restart: always
    environment:
      WORDPRESS_DB_HOST: mysql:3306
      WORDPRESS_DB_USER: root
      WORDPRESS_DB_PASSWORD: 123456
      WORDPRESS_DB_NAME: wordpress

编排部署owncloud

在master节点上编写/root/owncloud/docker-compose.yaml文件，具体要求如下：
（1）容器名称：owncloud；镜像：owncloud:latest；端口映射：5678:80；
（2）容器名称：mysql；镜像：mysql:5.6；
（3）MySQLroot用户密码：123456；
（4）创建数据库owncloud。
完成后编排部署owncloud。

version: '3'

services:
  mysql:
    image: mysql:5.6
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: ownclouds

  owncloud:
    depends_on:
      - mysql
    image: owncloud:latest
    restart: always
    links:
      - mysql:mysql
    ports:
      - 5678:80
    volumes:
      - /data/db/owncloud:/var/www/html/data

jenkins

在 master 节点上编写/root/jenkins/docker-compose.yaml 文件编排部署 Jenkins 服务，具体要求如下：（1）容器名称：jenkins；（2）端口映射：8080:8080；（3）使用 root 身份生成容器；（4）离线安装 Jenkins 插件；（5）设置 Jenkins 用户：springcloud；密码：000000；（6）在授权策略中配置“任何用户可以做任何事(没有任何限制)”。

version: '3.1' 
services:
  jenkins:
    image: 'jenkins/jenkins:2.262-centos'
    container_name: jenkins
    volumes: 
      - /home/jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
      - /usr/bin/docker:/usr/bin/docker
      - /usr/bin/kubectl:/usr/local/bin/kubectl 
      - /root/.kube:/root/.kube
    ports: 
      - "8080:8080" 
    expose: 
      - "8080"
      - "50000"
    privileged: true
    user: root
    restart: always

node{
     stage('git clone'){
           //check CODE
          git credentialsId: 'f2b9d90f-e743-46ce-8486-20af51ece8fa', url: 'http://192.168.59.20:81/root/springcloud'
        }
     stage('maven build'){
          sh '''/usr/local/maven/bin/mvn package -DskipTests -f /var/jenkins_home/workspace/springcloud'''
            }
      stage('image build'){
          sh ''' echo $BUILD_ID
         docker build -t 192.168.59.20/springcloud/gateway:$BUILD_ID -f /var/jenkins_home/workspace/springcloud/gateway/Dockerfile /var/jenkins_home/workspace/springcloud/gateway
         docker build -t 192.168.59.20/springcloud/config:$BUILD_ID -f /var/jenkins_home/workspace/springcloud/config/Dockerfile  /var/jenkins_home/workspace/springcloud/config'''
 }
    stage('test'){
        sh '''docker run -itd --name gateway 192.168.59.20/springcloud/gateway:$BUILD_ID
        docker ps -a|grep springcloud|grep Up
        if [ $? -eq 0 ];then
         echo "Success!" docker rm -f gateway
       else
       docker rm -f gateway
     exit 1
        fi
      ''' }
       stage('upload registry'){
         sh '''docker login 192.168.59.20 -u=admin -p=Harbor12345
         docker push 192.168.59.20/springcloud/gateway:$BUILD_ID
         docker push 192.168.59.20/springcloud/config:$BUILD_ID''' }
     stage('deploy Rancher'){
      //执行部署脚本
        sh 'sed -i "s/sqshq\\/piggymetrics-gateway/192.168.59.20\\/springcloud\\/gateway:$BUILD_ID/g" /var/jenkins_home/workspace/springcloud/yaml/deployment/gateway-deployment.yaml'
        sh 'sed -i "s/sqshq\\/piggymetrics-config/192.168.59.20\\/springcloud\\/config:$BUILD_ID/g" /var/jenkins_home/workspace/springcloud/yaml/deployment/config-deployment.yaml' 
        sh 'kubectl create ns springcloud'
        sh 'kubectl apply -f /var/jenkins_home/workspace/springcloud/yaml/deployment/gateway-deployment.yaml --kubeconfig=/root/.kube/config'
        sh 'kubectl apply -f /var/jenkins_home/workspace/springcloud/yaml/deployment/config-deployment.yaml --kubeconfig=/root/.kube/config'
        sh 'kubectl apply -f  /var/jenkins_home/workspace/springcloud/yaml/svc/gateway-svc.yaml --kubeconfig=/root/.kube/config'
        sh 'kubectl apply -f  /var/jenkins_home/workspace/springcloud/yaml/svc/config-svc.yaml --kubeconfig=/root/.kube/config'
   }
}

gitlab

在 master 节点上编写/root/gitlab/docker-compose.yaml 文件编排部署 Gitlab 服务，具体要求如下：

（1）容器名称：gitlab；

（2）端口映射：1022:22、81:80、443:443；

（3）容器重启策略：always；

（4）设置 root 用户及密码；

（5）使用 root 用户登录 Gitlab，密码：00000000；

（6）新建项目 Springcloud，将/opt/Springcloud 中的代码上传到 Springcloud 项目中

version: '3' 
services:
  gitlab:
    image: 'gitlab/gitlab-ce:12.9.2-ce.0'
    container_name: gitlab
    restart: always
    hostname: '10.24.2.156'
    privileged: true
    environment:
      TZ: 'Asia/Shanghai' 
    ports: 
      - '81:80' 
      - '443:443' 
      - '1022:22' 
    volumes: 
      - /srv/gitlab/config:/etc/gitlab
      - /srv/gitlab/gitlab/logs:/var/log/gitlab
      - /srv/gitlab/gitlab/data:/var/opt/gitlab

部署gpmall

安装docker

安装docker-ce docker-compose

master

# 关闭防火墙 mkdir /etc/docker  repo
# 使用脚本k8s_harbor_install.sh

关闭防火墙selinux
安装docker

# 离线安装包containerd-io、docker-ce docker-cli rpm安装
rpm -Uvh --force --nodeps *.rpm

yum install -y yum-utils
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum makecache fast
yum install -y docker-ce
systemctl start docker
systemctl enable docker

安装docker compose

mount /dev/sr0 /opt -o loop
cp -rfv /opt/docker-compose/v1.25.5-docker-compose-Linux-x86_64 /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
docker-compose version

安装私有仓库

在master节点安装私有仓库，导入/opt/images目录下所有镜像，并推送到私有仓库

#!/bin/bash
IMAGE_DIR="/opt/images"

for IMAGE in `ls $IMAGE_DIR`
do
  docker load -i $IMAGE_DIR/$IMAGE
done

解压安装包

mkdir harbor
cp -rfv /opt/harbor/harbor-offline-installer-v2.1.0.tgz harbor/
tar -zxvf harbor/harbor-offline-installer-v2.1.0.tgz
cd harbor/

配置信任私有仓库

方法一

vi /lib/systemd/system/docker.service
# 在[Service]
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock 加上 --insecure-registry 192.168.100.10

# 重启
systemctl daemon-reload
systemctl restart docker

方法二

mkdir /etc/docker
vi /etc/docker/daemon.json
{
  "insecure-registries": ["192.168.100.10"]
}

# 重启
systemctl daemon-reload
systemctl restart docker

修改配置信息

cp harbor.yml.tmpl harbor.yml
vi harbor.yml
hostname: 192.168.100.10   # 修改域名为本机ip
#https:  # 禁用https
  # https port for harbor, default is 443
  # port: 443
  # The path of cert and key files for nginx
  # certificate: /your/certificate/path
  # private_key: /your/private/key/path
  
harbor_admin_password: Harbor12345

安装

./prepare
./install.sh

推送镜像

docker tag mysql:5.6 192.168.100.20/library/mysql:5.6
docker push 192.168.100.20/library/mysql:5.6

容器化部署Redis

在 master 节点上编写/root/redis/Dockerfile 文件构建 chinaskill-redis:v1.1 镜像，具体要求如下：（需要用到的软件包路径 gpmall-single.tar.gz）

（1）基础镜像：centos:centos7.5.1804；

（2）作者：Chinaskill；

（3）修改配置文件中的 bind 127.0.0.1 为 bind 0.0.0.0；

（4）设置 Redis 免密，并关闭保护模式；

（5）开放端口：6379；

（6）设置服务开机自

编写yum

[centos]
name=centos
baseurl=http://192.168.59.50/centos7.5
enabled=1
gpgcheck=0
[gpmall]
name=gpmall
baseurl=http://192.168.59.50/paas20/ChinaskillMall/gpmall-repo
enabled=1
gpgcheck=0

编写dockerfile

FROM centos:centos7.5.1804
MAINTAINER Chinaskill
ADD gpmall.repo /etc/yum.repos.d/
RUN rm -rf /etc/yum.repos.d/C* && \
yum install -y redis* && \
sed -i "s/bind 127.0.0.1/bind 0.0.0.0/g" /etc/redis.conf && \
sed -i "s/protected-mod yes/protected-mod no/g" /etc/redis.conf
EXPOSE 6379
CMD ["redis-server","/etc/redis.conf"]

容器化部署 MariaDB

在 master 节点上编写/root/mariadb/Dockerfile 文件构建 chinaskill-mariadb:v1.1 镜像，具体要求如下：（需要用到的软件包路径 http:///gpmall-single.tar.gz）

（1）基础镜像：centos:centos7.5.1804；

（2）作者：Chinaskill；

（3）设置数据库密码：123456；

（4）创建数据库 gpmall 并导入数据库文件 gpmall.sql；

（5）设置字符编码：UTF-8；

（6）开放端口：3306； && port=8066

（7）设置服务开机自启

编写构建脚本

#!/bin/bash
# 初始化数据目录，--user以mysql系统用户执行，与目录的用户权限
mysql_install_db --user=root
# 启动mysql
mysqld_safe &
sleep 3
mysqladmin -u root password '123456'
mysql -uroot -p123456 -e "grant all privileges on *.* to 'root'@'%' identified by '123456';"
mysql -uroot -p123456 -e "create database gpmall;use gpmall;source /root/gpmall.sql;"

编写Dockerfile

FROM centos:centos7.5.1804
MAINTAINER Chinaskill
ADD gpmall.repo /etc/yum.repos.d/
ADD init.sh /opt
ADD gpmall.sql /opt
RUN rm -rf /etc/yum.repos.d/C* && \
yum install -y mariadb-server && \
sed -i "12a port=8066" /etc/my.cnf.d/server.cnf && \
chmod +x /opt/init.sh && \
sh /opt/init.sh
ENV LC_ALL en_US.utf-8
EXPOSE 8066
CMD ["mysqld_safe","--user=root"]

容器化部署 Zookeeper

在 master 节点上编写/root/zookeeper/Dockerfile 文件构建 chinaskill-zookeeper:v1.1 镜像，具体要求如下：（需要用到的软件包路径 http:///gpmall-single.tar.gz）

（1）基础镜像：centos:centos7.5.1804；

（2）作者：Chinaskill；

（3）开放端口：2181；

（4）设置服务开机自启。

配置文件说明

# The number of milliseconds of each tick
# 通信心跳时间，Zookeeper服务器与客户端心跳时间，单位毫秒。
tickTime=2000

# The number of ticks that the initial 
# synchronization phase can take
# LF初始通信时限。
# Leader和Follower初始连接时能容忍的最多心跳数，单位次（即tickTime的数量）。
initLimit=10

# The number of ticks that can pass between 
# sending a request and getting an acknowledgement
# LF同步通信时限。
# Leader和Follower连接之后，通信时能容忍的最多心跳数，单位次。
# 时间如果超过syncLimit * tickTime，Leader认为Follwer挂掉，从服务器列表中删除Follwer。
syncLimit=5

# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just 
# example sakes.
# 保存Zookeeper中的数据的目录。
dataDir=/opt/module/apache-zookeeper-3.5.7-bin/zkData

# the port at which the clients will connect
# 客户端连接端口，通常不做修改。
clientPort=2181

准备工作

mkdir /root/zookeeper
cd /root/zookeeper
cp /root/mariadb/ftp.repo .
cp /opt/ChinaskillMall/zookeeper-3.4.14.tar.gz .

编写Dockerfile

FROM centos:centos7.5.1804
MAINTAINER Chinaskill
ADD gpmall.repo /etc/yum.repos.d/
ADD zookeeper-3.4.14.tar.gz /opt
ENV ZK_HOME=/opt/zookeeper-3.4.14
ENV PATH=$PATH:$ZK_HOME/bin
RUN rm -rf /etc/yum.repos.d/C* && \
yum install -y java-1.8.0* && \
cp $ZK_HOME/conf/zoo_sample.cfg $ZK_HOME/conf/zoo.cfg
EXPOSE 2181
CMD ["sh","-c","zkServer.sh start-foreground && tail -f /etc/shadow"]

容器化部署 Kafka

（1）基础镜像：centos:centos7.5.1804；

（2）作者：Chinaskill；

（3）开放端口：9092；

（4）设置服务开机自启

准备工作

mkdir kafka
cd kafka/
cp /root/zookeeper/http.repo .
cp /opt/ChinaskillMall/zookeeper-3.4.14.tar.gz .
cp /opt/ChinaskillMall/kafka_2.11-1.1.1.tgz .

编写Dockerfile

FROM centos:centos7.5.1804
MAINTAINER Chinaskill
ADD gpmall.repo /etc/yum.repos.d/
ADD kafka_2.11-1.1.1.tgz /opt
ADD zookeeper-3.4.14.tar.gz /opt
RUN rm -rf /etc/yum.repos.d/C* && \
yum install -y java-1.8.0* && \
cp /opt/zookeeper-3.4.14/conf/zoo_sample.cfg /opt/zookeeper-3.4.14/conf/zoo.cfg
EXPOSE 9092
CMD ["sh","-c","/opt/zookeeper-3.4.14/bin/zkServer.sh start && /opt/kafka_2.11-1.1.1/bin/kafka-server-start.sh /opt/kafka_2.11-1.1.1/config/server.properties"]

容器化部署 Nginx

在 master 节点上编写/root/nginx/Dockerfile 文件，基于提供的软件包 gpmall-single.tar 构建 chinaskillnginx:v1.1 镜像，具体要求如下：

（1）基础镜像：centos:centos7.5.1804；

（2）作者：Chinaskill；

（3）编写/etc/nginx/conf.d/default.conf 文件，配置反向代理，将 80 端口请求转发到 8081、8082 和 8083；

（4）将 dist.tar 解压并复制到/usr/share/nginx/html/ 目录下；

（5）开放端口：80、443、8081、8082、8083；

（6）设置服务开机自启。

准备工作

mkdir /root/nginx
cd /root/nginx
cp /root/kafka/http.repo .
cp -rfv /opt/ChinaskillMall/*.jar .
cp -rfv /opt/ChinaskillMall/dist .
vi jarstart.sh

配置jarstart.sh

/usr/sbin/nginx
nohup java -jar /root/jar/shopping-provider-0.0.1-SNAPSHOT.jar &
sleep 30
nohup java -jar /root/jar/user-provider-0.0.1-SNAPSHOT.jar &
sleep 40
nohup java -jar /root/jar/gpmall-shopping-0.0.1-SNAPSHOT.jar &
sleep 30
java -jar /root/jar/gpmall-user-0.0.1-SNAPSHOT.jar

编写dockerfile

FROM centos:centos7.5.1804
MAINTAINER chinaskill
RUN rm -rf /etc/yum.repos.d/*
ADD gpmall.repo /etc/yum.repos.d/
COPY jar/ /root/jar/
ADD jarstart.sh /
RUN yum -y install nginx java-1.8.0-openjdk java-1.8.0-openjdk-devel && \
sed -i "1a location /shopping { proxy_pass http://127.0.0.1:8081 ;}" /etc/nginx/conf.d/default.conf && \
sed -i "2a location /user { proxy_pass http://127.0.0.1:8082 ;}" /etc/nginx/conf.d/default.conf && \
sed -i "3a location /cashier { proxy_pass http://127.0.0.1:8083 ;}" /etc/nginx/conf.d/default.conf && \
chmod +x /jarstart.sh && \
rm -rf /usr/share/nginx/html/*
COPY dist/ /usr/share/nginx/html/
EXPOSE 80 443 8081 8082 8083
CMD ["sh","/jarstart.sh"]

编排部署 GPMall 商城

在 master 节点上编写/root/chinaskillmall/dockercompose.yaml 文件，具体要求如下：

（1）容器 1 名称：mysql；镜像：chinaskillmariadb:v1.1；端口映射：3306:3306；

（2）容器 2 名称：redis；镜像：chinaskillredis:v1.1；端口映射：6379:6379；

（3）容器 3 名称：kafka；镜像：chinaskillkafka:v1.1；端口映射：9092:9092；

（4）容器 4 名称：zookeeper；镜像：chinaskillzookeeper:v1.1；端口映射：2181:2181； - 13 -

（5）容器 5 名称：nginx；镜像：chinaskillnginx:v1.1；端口映射：80:80，443:443。

mkdir /root/chinaskillmall
vi /root/chinaskillmall/docker-compose.yaml

version: "3.8"
services:
  mysql.mall:
    container_name: mall-db
    image: chinaskill-mariadb:v1.1
    ports:
      - 8066:8066
  redis.mall:
    container_name: mall-redis
    image: chinaskill-redis:v1.1
    depends_on:
      - mysql.mall
    ports:
      - 6379:6379
  zk1.mall:
    container_name: mall-zookeeper
    image: chinaskill-zookeeper:v1.1
    ports:
      - 2181:2181
  kafka1.mall:
    container_name: mall-kafka
    image: chinaskill-kafka:v1.1
    ports:
      - 9092:9092
    depends_on:
      - zk1.mall
  nginx.mall:
    depends_on:
      - mysql.mall
      - redis.mall
      - zk1.mall
      - kafka1.mall
    container_name: mall-nginx
    image: chinaskill-nginx:v1.1
    ports:
      - 83:80
      - 1443:443

部署Hyperf

准备环境，files.tar.gz、Hyperf.tzr.gz

[root@master ~]# ls
anaconda-ks.cfg  files.tar.gz  Hyperf.tar.gz
[root@master ~]# tar -xvf Hyperf.tar.gz
[root@master ~]# tar -xvf files.tar.gz -C Hyperf/
[root@master ~]# cp -rf Hyperf/yum/ /opt/

部署ftp
anon_root=/opt/yum
[root@master ~]# cat /etc/yum.repos.d/local.repo 
[local]
name=local
baseurl=ftp://192.168.100.10
enabled=1
gpgcheck=0

[root@master ~]# docker load -i Hyperf/images/centos_7.9.2009.tar

容器化 MariaDB 服务

编写Dockerfile文件构建hyperf-mariadb:v1.0镜像，具体要求如下：（需要用到的软件包： Hyperf.tar.gz）（1）基础镜像：centos:7.9.2009；（2）完成 MariaDB 服务的安装；（3）声明端口：3306；（4）设置数据库 root 用户的密码为 root；（5）将提供的数据库文件 hyperf_admin.sql 导入数据库；（6）设置服务开机自启。

#!/bin/bash
mysql_install_db --user=root
mysqld_safe --user=root &
sleep 8
mysqladmin -u root password 'root'
mysql -uroot -proot -e "grant all on *.* to 'root'@'%' identified by 'root';"
mysql -uroot -proot -e "grant all on *.* to 'root'@'localhost' identified by 'root'; flush privileges;"
mysql -uroot -proot -e "source /opt/hyperf_admin.sql;source /opt/test.sql;"

FROM centos:7.9.2009
RUN rm -rf /etc/yum.repos.d/*
COPY local.repo /etc/yum.repos.d/
WORKDIR /opt
ENV LC_ALL en_US.UTF-8
COPY ./project/docker/db/hyperf_admin.sql ./project/docker/db/test.sql mysql_init.sh ./
RUN yum -y install MariaDB-server MariaDB-client MariaDB-devel
RUN chmod +x /opt/mysql_init.sh && bash /opt/mysql_init.sh
EXPOSE 3306
CMD ["mysqld_safe","--user=root"]

docker build -t hyperf-mariadb:v1.0 .

容器化 Redis 服务

编写 Dockerfile 文件构建 hyperf-redis:v1.0 镜像，具体要求如下：（需要用到的软件包： Hyperf.tar.gz）（1）基础镜像：centos:7.9.2009；（2）安装 Redis 服务；（3）关闭保护模式；（4）声明端口：6379；（5）设置服务开机自启。

FROM centos:7.9.2009
RUN rm -rf /etc/yum.repos.d/*
COPY local.repo /etc/yum.repos.d/
RUN yum install -y redis* && \
sed -i 's/127.0.0.1/0.0.0.0/g' /etc/redis.conf && \
sed -i "s/portected-mode yes/protectd-mode no/g" /etc/redis.conf
EXPOSE 6379
CMD ["redis-server","/etc/redis.conf"]

容器化 Nginx 服务

编写 Dockerfile 文件构建 hyperf-nginx:v1.0 镜像，具体要求如下：（需要用到的软件包： Hyperf.tar.gz）（1）基础镜像：centos:7.9.2009；（2）安装 nginx 服务；（3）声明端口：80；（4）设置服务开机自启。

FROM centos:7.9.2009
RUN rm -rf /etc/yum.repos.d/*
COPY local.repo /etc/yum.repos.d/
WORKDIR /opt
RUN yum -y install nginx
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

容器化 Hyperf 服务

编写 Dockerfile 文件构建 hyperf-service:v1.0 镜像，具体要求如下：（需要用到的软件包： Hyperf.tar.gz）（1）基础镜像：centos:7.9.2009；（2）安装 PHP 及扩展；（3）使用源码编译安装 Swoole。

FROM centos:7.9.2009
RUN rm -rf /etc/yum.repos.d/*
COPY local.repo /etc/yum.repos.d/
WORKDIR /opt
RUN yum -y install php php-* composer
C swoole-v4.8.3.zip ./
RUN yum -y install unzip && unzip swoole-v4.8.3.zip
RUN mv /opt/swoole-v4.8.3 /opt/swoole && cd /opt/swoole && phpize && ./configure && make &&make install
RUN php -v && echo "extension=swoole.so" > /etc/php.d/50_swoole.ini \
&& echo "swoole.use_shortname = 'Off'" >> /etc/php.d/50_swoole.ini \
&& php -m \
&& composer --version \
COPY ./project/backend /data

docker-compose编译

编写/root/hyperf/project/docker-compose.yaml 文件，具体要求如下：（1）容器 1 名称：hyperf-mysql；镜像：hyperf-mariadb:v1.0；端口映射：3306:3306；（2）容器 2 名称：hyperf-redis；镜像：hyperf-redis:v1.0；（3）容器 3 名称：hyperf-ui；镜像：hyperf-nginx:v1.0；端口映射：80:8081；（4）容器 4 名称：hyperf-service；镜像：hyperf-service:v1.0。完成后编排部署 Hyperf 框架，并提交 master 节点的用户名、密码和 IP 地址到答题框。

version: '3.1'
services:
  app:
    container_name: hyperf-service
    image:  hyperf-service:v1.0
    command:
      - /bin/sh
      - -c
      - |
        cd /data
        cp .env.dev.docker .env
        php -d memory_limit=-1 `which composer` i --no-dev
        rm -rf runtime/*
        php bin/hyperf.php start
    volumes:
      - ./backend:/data
    tty: true
    links:
      - mysql
      - redis
    environment:
      HOST_IP: 127.0.0.1
      HOST_PORT: 9511
  mysql:
    container_name: hyperf-mysql
    image: hyperf-mariadb:v1.0
    ports:
      - 3306:3306
    restart: always
  redis:
    image: hyperf-redis:v1.0
    container_name: hyperf-redis
    restart: always
  nginx:
    image: hyperf-nginx:v1.0
    container_name: hyperf-nginx
    ports:
      - 8081:80
    links:
      - app
    volumes:
      - ./conf.d/:/etc/nginx/conf.d
      - ./docker/log:/var/log/nginx
      - ./frontend:/var/www/frontend

亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责