定制自己的web服务器

  1. FROM nginx:latest
  2. RUN echo '<h1>hello, docker</h1>' > /usr/share/nginx/html/index.html
  1. docker build -t nginx:test . // 制作镜像
  2. docker run -p 5001:80 -d nginx:test // 启动镜像

定制react服务器 - 使用docker-compose.yml方法

  • nginx 中配置端口与compose中的文件一致
  • 注意volumes中的文件映射
  • 该实例只是把编译以后的文件映射到docker中，不涉及代码编译
  • docker-compose up -d
  • docker-compose down
    1. version: '2'
    2. services:
    3. # 服务名称
    4. nginx:
    5.   # 镜像：版本
    6.   image: nginx:latest
    7.   #映射容器81端口到本地81端口
    8.   ports:
    9.     - "8080:80"
    10.   # 数据卷，映射本地文件到容器
    11.   volumes:
    12.   # 映射nginx.conf文件到容器的/etc/nginx/conf.d目录并覆盖default.conf文件
    13.     - ./nginx.conf:/etc/nginx/conf.d/default.conf
    14.   # 映射build文件夹到容器的/usr/share/nginx/html文件夹
    15.     - ./dist:/usr/share/nginx/html
    16.   # 覆盖容器启动后默认执行命令
    17.   # command: /bin/bash -C "nginx -g 'daemon off;'"
    ```nginx

    gzip设置

    gzip on; gzip_vary on;

gzip_comp_level 6; gzip_buffers 16 8k;

gzip_min_length 1000; gzip_proxied any; gzip_disable “msie6”;

gzip_http_version 1.0;

gzip_types text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript application/javascript;

  1. upstream zioms{
  2.     server 10.251.181.40:18889 weight=1 max_fails=2 fail_timeout=30s;
  3.     server 10.251.181.41:18889 weight=1 max_fails=2 fail_timeout=30s;
  4. }

server { listen 80; server_name localhost;

  1. #charset koi8-r;
  2. #access_log  /var/log/nginx/host.access.log  main;
  4. location / {
  5.     root   /usr/share/nginx/html;
  6.     index  index.html index.htm;
  7.     # 其作用是按顺序检查文件是否存在，返回第一个找到的文件或文件夹（结尾加斜线表示为文件夹），如果所有的文件或文件夹都找不到，会进行一个内部重定向到最后一个参数。
  8.     try_files $uri /index.html;
  9. }
  11. location /html/zioms/ {
  12.     alias  /usr/share/nginx/html/;
  13.     index  index.html index.htm;
  14.     # 其作用是按顺序检查文件是否存在，返回第一个找到的文件或文件夹（结尾加斜线表示为文件夹），如果所有的文件或文件夹都找不到，会进行一个内部重定向到最后一个参数。
  15.     try_files $uri /index.html;
  16. }
  18.     #智慧运维平台-java
  19. location /zioms/ {
  20.     proxy_pass http://zioms/;
  21. }
  25. #error_page  404              /404.html;
  27. # redirect server error pages to the static page /50x.html
  28. #
  29. error_page   500 502 503 504  /50x.html;
  30. location = /50x.html {
  31.     root   /usr/share/nginx/html;
  32. }
  34. # proxy the PHP scripts to Apache listening on 127.0.0.1:80
  35. #
  36. #location ~ \.php$ {
  37. #    proxy_pass   http://127.0.0.1;
  38. #}
  40. # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
  41. #
  42. #location ~ \.php$ {
  43. #    root           html;
  44. #    fastcgi_pass   127.0.0.1:9000;
  45. #    fastcgi_index  index.php;
  46. #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
  47. #    include        fastcgi_params;
  48. #}
  50. # deny access to .htaccess files, if Apache's document root
  51. # concurs with nginx's one
  52. #
  53. #location ~ /\.ht {
  54. #    deny  all;
  55. #}

}

  1. <a name="wUaEC"></a>
  2. ## 定制react项目
  4. 1. dockerignore
  5. ```bash
  6. node_modules
  1. Dockerfile ```bash

    node 镜像

    apline 版本的node会小很多

    FROM node:12-alpine

在容器中创建目录

RUN mkdir -p /usr/src/app

指定工作空间，后面的指令都会在当前目录下执行

WORKDIR /usr/src/app

拷贝 package.json

COPY package.json /usr/src/app

安装依赖

RUN npm i —production —registry=https://registry.npm.taobao.org

拷贝其他所有文件到容器（除了 .dockerignore 中的目录和文件）

COPY . /usr/src/app

build

RUN npm run build

暴露端口 9000

EXPOSE 9000

运行容器时执行命令，每个 Dokcerfile 只能有一个 CMD 命令，多个的话只有最后一个会执行

CMD [ “npm”, “start” ]

  2. 3. docker-compose.yml
  3. ```bash
  4. version: '3'
  5. services:
  6.   web:
  7.     build:
  8.       context: ../
  9.       dockerfile: ./docker/Dockerfile
  10.     image: react_blog:blog
  11.     ports:
  12.       - 9000:9000
  13.     container_name: react_blog_blog

Docker 镜像是分层的，下面这些知识点非常重要：

  • Dockerfile 中的每个指令都会创建一个新的镜像层，每个 RUN 都是一个指令 docs.docker.com/engine/refe…
  • 镜像层将被缓存和复用
  • 当 Dockerfile 的指令修改了，复制的文件变化了，或者构建镜像时指定的变量不同了，对应的镜像层缓存就会失效
  • 某一层的镜像缓存失效之后，它之后的镜像层缓存都会失效
  • 镜像层是不可变的，如果我们再某一层中添加一个文件，然后在下一层中删除它，则镜像中依然会包含该文件(只是这个文件在 Docker 容器中不可见了)。

所以我们先拷贝 package.json，然后 RUN npm i 安装依赖，形成一个镜像层，再拷贝其他所有文件，形成一个镜像层，之后如果代码有所变动，但是 package.json 没有变动，再次执行时，就不会再安装依赖了，可以节省很多时间。package.json 有变动，才会重新执行 RUN run i 安装依赖。
假如生成了镜像 imageA，此时要删除 imageA，重新生成，记住先生成新的镜像 imageB，这样才会复用 npm 包，如果先删除了 imageA，再新生成 imageB，则又会重新安装依赖。

  • 生成镜像 docker build -t hello-react-app .
  • 运行镜像 docker run -it -p 8001:8001 hello-react-app