Dockerfile及其部署镜像步骤

Docker部署镜像(一) Docker部署镜像(一) 文章目录Docker部署镜像(一)前言一、Docker安装二、部署镜像1.MySQL2.Tomcat3.Redis4.Mongo5.Nacos6.RabbitMQ7.ElasticSearch8.Kibana总结 前言 在进行项目的开发过程中,往往需要各种中间件环境的搭建,如果去各种中间件官网进行下载安装,就显得过于麻烦,而且调试完自己编程环境后再到部署线上同时也要在服务器搭建环境。这时,Docker容器化的优势就显现出来了。 一、Docker安装 Linux: yum i 阅读详情

Dockerfile

一键创建Docker镜像

通过编写Dockerfile,可以将环境配置、应用程序代码、依赖关系等打包成一个镜像,便于快速创建容器。

Dockerfile常用指令

Dockerfile 指令说明(都是大写字母)
FROM指定基础镜像(父镜像)
LABEL添加新建镜像的元数据(镜像的基本信息,作者、邮箱、简介),使用键值对的形式
RUN在容器中执行Linux命令,命令之间用&&连接
ENV在容器中设置环境变量
ADD复制本地文件自动解压缩,支持URL下载
COPY将文件或目录复制到镜像中,只有复制功能
VOLUME指定持久化目录
CMD容器启动时执行的命令(会被运行的命令覆盖)
ENTRYPOINT容器启动时执行的命令(不会被运行的命令覆盖)
WORKDIR工作目录,等价执行cd命令
EXPOSE指定对外暴露端口
USER指定后续指令的用户上下文。USER <用户名>[:<用户组>]
ARG定义在构建过程中传递给构建器的变量,可使用 "docker build" 命令设置。ARG <参数名>[=<默认值>]
ONBUILD当该镜像被用作另一个构建过程的基础时,添加触发器。ONBUILD <其它指令>
STOPSIGNAL设置发送给容器以退出的系统调用信号。
HEALTHCHECK定义周期性检查容器健康状态的命令。用于指定某个程序或者指令来监控 docker 容器服务的运行状态。 HEALTHCHECK [选项] CMD <命令>:设置检查容器健康状况的命令 HEALTHCHECK NONE:如果基础镜像有健康检查指令,使用这行可以屏蔽掉其健康检查指令 HEALTHCHECK [选项] CMD <命令> : 这边 CMD 后面跟随的命令使用,可以参考 CMD 的用法。
SHELL覆盖Docker中默认的shell,用于RUN、CMD和ENTRYPOINT指令。
 举例:
 vim Dockerfile
 ​
 FROM nginx:1.26
 LABEL email=zuojie@88.com
 RUN apt update && apt install -y vim unzip
 ENV webpath=/data/www/html
 RUN mkdir -p $webpath
 ADD h5-online-mini-game.zip $webpath
 RUN ls $webpath
 WORKDIR $webpath
 RUN unzip h5-online-mini-game.zip && mv h5-online-mini-game h5
 ADD default.conf /etc/nginx/conf.d/
 VOLUME ["/etc/nginx","$webpath"] IEXPOSE 80/tcp 443/tcp
 #ENTRYPOINT /docker-entrypoint.sh
 #CMD nginx g daemon off
 ​
 #通过Dockerfile创建镜像
 docker build -t nginx-test .

实例1:构建nginx镜像

 # 1、拉取nginx镜像
 docker pull nginx:1.26
 docker images
 # 创建项目目录和文件
 mkdir -p /data/dockerfile/nginx
 cd /data/dockerfile/nginx(后续都在这个目录里)
 # 2、创建Dockerfile
 vim Dockerfile
 ---------------------------------------
 # 使用官方Nginx镜像作为基础镜像
 FROM nginx:latest
 # 维护者信息(可选)
 LABEL maintainer="your-email@example.com"
 # 复制自定义Nginx配置文件
 COPY default.conf /etc/nginx/conf.d/default.conf
 # 复制网站文件到Nginx默认目录
 COPY html /usr/share/nginx/html
 # 设置工作目录
 WORKDIR /usr/share/nginx/html
 # 暴露Nginx默认端口
 EXPOSE 80
 # 使用Nginx默认启动命令(可以省略,因为会继承基础镜像的CMD)
 CMD ["nginx", "-g", "daemon off;"]
 ---------------------------------------
 # 3、创建Nginx配置文件
 vim default.conf
 ---------------------------------------
 server {
     listen       80;
     listen  [::]:80;
     server_name  localhost;
     
     # 访问日志设置
     access_log  /var/log/nginx/host.access.log  main;
     
     # 网站根目录
     location / {
         root   /usr/share/nginx/html;
         index  index.html index.htm;
     }
 ​
     # 错误页面配置
     error_page   500 502 503 504  /50x.html;
     location = /50x.html {
         root   /usr/share/nginx/html;
     }
     
     # 健康检查端点
     location /health {
         access_log off;
         return 200 "healthy\n";
         add_header Content-Type text/plain;
     }
 }
 ---------------------------------------
 # 4、创建网站内容
 # 创建html目录
 mkdir html
 # 创建首页(随便写一句话,这个仅供参考)
 vim html/index.html
 ---------------------------------------
 <!DOCTYPE html>
 <html lang="zh-CN">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Welcome to My Nginx</title>
     <style>
         body {
             font-family: Arial, sans-serif;
             max-width: 800px;
             margin: 0 auto;
             padding: 20px;
             background-color: #f5f5f5;
         }
         .container {
             background: white;
             padding: 30px;
             border-radius: 8px;
             box-shadow: 0 2px 10px rgba(0,0,0,0.1);
         }
         h1 {
             color: #333;
             border-bottom: 2px solid #4CAF50;
             padding-bottom: 10px;
         }
         .info {
             background: #e7f3ff;
             padding: 15px;
             border-left: 4px solid #2196F3;
             margin: 20px 0;
         }
     </style>
 </head>
 <body>
     <div class="container">
         <h1>🚀 Welcome to My Custom Nginx</h1>
         <p>这是一个基于Docker自定义构建的Nginx服务器</p>
         
         <div class="info">
             <h3>📋 服务器信息</h3>
             <p><strong>服务器:</strong> Nginx in Docker Container</p>
             <p><strong>构建时间:</strong> 2024</p>
             <p><strong>状态:</strong> ✅ 运行正常</p>
         </div>
         
         <h3>🔗 可用链接</h3>
         <ul>
             <li><a href="/">首页</a></li>
             <li><a href="/health">健康检查</a></li>
         </ul>
     </div>
 </body>
 </html>
 ---------------------------------------
 # 5、创建错误页面(可跳过)
 vim html/50x.html
 ---------------------------------------
 <!DOCTYPE html>
 <html>
 <head>
     <title>Error</title>
     <style>
         body { 
             font-family: Arial, sans-serif; 
             text-align: center; 
             padding: 50px; 
         }
         .error { 
             color: #d9534f; 
             font-size: 48px; 
         }
     </style>
 </head>
 <body>
     <div class="error">500</div>
     <h2>服务器内部错误</h2>
     <p>抱歉,服务器遇到了问题,请稍后重试。</p>
 </body>
 </html>
 ---------------------------------------
 # 6、构建Docker镜像并验证
 docker build -t mynginx:latest .
 docker images | grep mynginx
 docker history mynginx:latest
 # 7、运行容器
 # 运行容器(后台模式)
 docker run -d \
   --name mynginx-container \
   -p 80:80 \
   mynginx:latest
 # 8、测试访问
 # 检查容器状态
 docker ps
 # 查看容器日志
 docker logs mynginx-container
 # 测试访问(使用浏览器访问IP)
 # 9、推送镜像到镜像仓库(补充内容,可以省略)
 # 登录到Docker Hub或其他镜像仓库
 docker login
 # 重新标记镜像(如果需要推送到Docker Hub)
 docker tag mynginx:latest yourusername/mynginx:latest
 # 推送镜像
 docker push yourusername/mynginx:latest

实例2:构建Tomcat应用镜像

 #1. 创建项目目录和文件
 mkdir -p /data/dockerfile/tomcat
 cd /data/dockerfile/tomcat
 #2. 创建Dockerfile
 vim Dockerfile
 ===========================================
 内容如下:
 # 使用官方的 Ubuntu 镜像作为基础镜像
 FROM ubuntu:22:04
 # 设置 JAVA_HOME 环境变量
 ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
 ENV PATH=$PATH:$JAVA_HOME/bin
 # 下载并安装 Tomcat
 ARG TOMCAT_VERSION=9.0.87
 ENV TOMCAT_VERSION=$TOMCAT_VERSION
 # 使用局域网安装包(根据你的实际情况修改IP地址)
 RUN wget http://192.168.57.200/Software/apache-tomcat-${TOMCAT_VERSION}.tar.gz -O /tmp/tomcat.tar.gz && \
     tar -xvf /tmp/tomcat.tar.gz -C /opt/ && \
     ln -s /opt/apache-tomcat-${TOMCAT_VERSION} /opt/tomcat && \
     rm /tmp/tomcat.tar.gz
 # 设置 CATALINA_HOME 环境变量
 ENV CATALINA_HOME=/opt/tomcat
 ENV PATH=$PATH:$CATALINA_HOME/bin
 # 创建Tomcat用户和组
 RUN groupadd -r tomcat && \
     useradd -r -g tomcat -d /opt/tomcat -s /bin/false tomcat && \
     chown -R tomcat:tomcat /opt/apache-tomcat-${TOMCAT_VERSION} && \
     chmod +x /opt/tomcat/bin/*.sh
 # 创建webapps目录(确保存在)
 RUN mkdir -p /opt/tomcat/webapps
 # 复制自定义应用(可选)
 # COPY myapp.war /opt/tomcat/webapps/
 # 暴露 Tomcat 默认的 HTTP 端口
 EXPOSE 8080
 # 设置工作目录
 WORKDIR /opt/tomcat
 # 切换用户(安全考虑)
 USER tomcat
 # 启动 Tomcat 服务
 CMD ["catalina.sh", "run"]
 ============================================
 ----------------------------------------------------------------
 3. 创建测试应用(中间这几步可以不做,默认丑猫页面)
 mkdir webapps
 cd webapps
 创建简单的测试页面:
 # 创建测试WAR应用的目录结构
 mkdir -p myapp/WEB-INF
 cd myapp
 # 创建 index.jsp:
 vim index.jsp
 <!DOCTYPE html>
 <html>
 <head>
     <title>Tomcat Test Application</title>
     <style>
         body { font-family: Arial, sans-serif; margin: 40px; }
         .container { max-width: 800px; margin: 0 auto; }
         .info { background: #e7f3ff; padding: 15px; border-left: 4px solid #2196F3; }
     </style>
 </head>
 <body>
     <div class="container">
         <h1>🚀 Tomcat Docker 测试应用</h1>
         <div class="info">
             <h3>服务器信息</h3>
             <p><strong>Java 版本:</strong> <%= System.getProperty("java.version") %></p>
             <p><strong>Tomcat 版本:</strong> <%= application.getServerInfo() %></p>
             <p><strong>当前时间:</strong> <%= new java.util.Date() %></p>
         </div>
         <h3>测试链接</h3>
         <ul>
             <li><a href="/">首页</a></li>
             <li><a href="/manager">管理界面</a></li>
         </ul>
     </div>
 </body>
 </html>
 # 创建 WEB-INF/web.xml:
 mkdir -p WEB-INF
 vim WEB-INF/web.xml
 内容:
 xml
 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
     
     <display-name>Tomcat Test Application</display-name>
     <description>
         A simple test application for Tomcat Docker image
     </description>
     
     <welcome-file-list>
         <welcome-file>index.jsp</welcome-file>
     </welcome-file-list>
 </web-app>
 # 打包WAR文件:
 # 返回项目根目录
 cd /data/dockerfile/tomcat
 # 打包WAR文件
 jar -cvf myapp.war -C webapps/myapp/ .
 # 将WAR文件复制到Docker构建上下文
 cp myapp.war ./
 4. 修改Dockerfile以包含应用
 如果需要包含测试应用,取消注释并修改Dockerfile:
 dockerfile
 # 在COPY部分取消注释:
 COPY myapp.war /opt/tomcat/webapps/
 --------------------------------------------------------------
 #3. 构建镜像
 docker build -t my-tomcat:9.0.87 -t my-tomcat:latest .
 # 查看构建的镜像
 docker images my-tomcat
 #4. 运行容器
 # 运行容器(基础版本)
 docker run -d --name tomcat-container -p 8080:8080 my-tomcat:latest
 #5. 测试访问
 # 检查容器状态
 docker ps
 # 查看容器日志
 docker logs tomcat-container
 # 测试访问
 curl http://localhost:8080
 # 如果部署了测试应用,访问:
 curl http://localhost:8080/myapp/
 #扩展. 使用Docker Compose()
 创建 docker-compose.yml:
 yaml
 version: '3.8'
 services:
   tomcat:
     image: my-tomcat:latest
     container_name: tomcat-app
     ports:
       - "8080:8080"
     volumes:
       - ./webapps:/opt/tomcat/webapps
       - ./logs:/opt/tomcat/logs
     environment:
       - JAVA_OPTS=-Xms512m -Xmx1024m
     restart: unless-stopped
 使用Compose运行:
 docker-compose up -d

实例3:Docker部署单机小游戏

 #1. 创建项目目录
 mkdir -p /data/games/snake
 cd /data/games/snake
 #2. 创建游戏文件
 vim index.html
 ----------------------------------------------------------------
 <!DOCTYPE html>
 <html lang="zh-CN">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>贪吃蛇游戏</title>
     <style>
         body {
             display: flex;
             justify-content: center;
             align-items: center;
             min-height: 100vh;
             margin: 0;
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             font-family: Arial, sans-serif;
         }
         .game-container {
             text-align: center;
             background: white;
             padding: 30px;
             border-radius: 15px;
             box-shadow: 0 15px 35px rgba(0,0,0,0.3);
         }
         h1 {
             color: #333;
             margin-bottom: 20px;
             font-size: 2.5em;
         }
         canvas {
             border: 3px solid #333;
             background: #000;
             display: block;
             margin: 0 auto;
         }
         .score {
             font-size: 28px;
             margin: 15px 0;
             color: #333;
             font-weight: bold;
         }
         .controls {
             margin-top: 20px;
             color: #666;
             font-size: 16px;
         }
         .game-over {
             color: #e74c3c;
             font-size: 24px;
             font-weight: bold;
             margin: 10px 0;
         }
         .restart-btn {
             padding: 12px 25px;
             margin: 15px 0;
             border: none;
             background: #2ecc71;
             color: white;
             border-radius: 8px;
             cursor: pointer;
             font-size: 16px;
             font-weight: bold;
             transition: background 0.3s;
         }
         .restart-btn:hover {
             background: #27ae60;
         }
     </style>
 </head>
 <body>
     <div class="game-container">
         <h1>🐍 贪吃蛇游戏</h1>
         <div class="score">得分: <span id="score">0</span></div>
         <div id="gameOver" class="game-over" style="display: none;">游戏结束! 按空格键重新开始</div>
         <canvas id="gameCanvas" width="400" height="400"></canvas>
         <button class="restart-btn" onclick="resetGame()">重新开始游戏</button>
         <div class="controls">
             使用 ↑ ↓ ← → 方向键控制蛇的移动<br>
             按空格键可以快速重新开始
         </div>
     </div>
 ​
     <script>
         const canvas = document.getElementById('gameCanvas');
         const ctx = canvas.getContext('2d');
         const scoreElement = document.getElementById('score');
         const gameOverElement = document.getElementById('gameOver');
 ​
         // 游戏配置
         const gridSize = 20;
         const tileCount = canvas.width / gridSize;
 ​
         // 游戏状态
         let snake = [];
         let food = {};
         let dx = 0;
         let dy = 0;
         let score = 0;
         let gameRunning = true;
         let gameSpeed = 120; // 毫秒
 ​
         // 初始化游戏
         function initGame() {
             snake = [
                 {x: 10, y: 10},
                 {x: 9, y: 10},
                 {x: 8, y: 10}
             ];
             dx = 1; // 初始向右移动
             dy = 0;
             score = 0;
             scoreElement.textContent = score;
             gameRunning = true;
             gameOverElement.style.display = 'none';
             randomFood();
         }
 ​
         // 随机生成食物
         function randomFood() {
             let newFood;
             let onSnake;
             
             do {
                 newFood = {
                     x: Math.floor(Math.random() * tileCount),
                     y: Math.floor(Math.random() * tileCount)
                 };
                 onSnake = snake.some(segment => 
                     segment.x === newFood.x && segment.y === newFood.y
                 );
             } while (onSnake);
             
             food = newFood;
         }
 ​
         // 绘制游戏
         function drawGame() {
             // 清空画布
             ctx.fillStyle = '#1a1a1a';
             ctx.fillRect(0, 0, canvas.width, canvas.height);
 ​
             // 绘制网格(可选)
             ctx.strokeStyle = '#333';
             for (let i = 0; i < tileCount; i++) {
                 for (let j = 0; j < tileCount; j++) {
                     ctx.strokeRect(i * gridSize, j * gridSize, gridSize, gridSize);
                 }
             }
 ​
             // 绘制蛇
             snake.forEach((segment, index) => {
                 if (index === 0) {
                     // 蛇头
                     ctx.fillStyle = '#2ecc71';
                 } else {
                     // 蛇身
                     ctx.fillStyle = '#27ae60';
                 }
                 ctx.fillRect(segment.x * gridSize, segment.y * gridSize, gridSize - 1, gridSize - 1);
                 
                 // 蛇身边框
                 ctx.strokeStyle = '#fff';
                 ctx.strokeRect(segment.x * gridSize, segment.y * gridSize, gridSize - 1, gridSize - 1);
             });
 ​
             // 绘制食物
             ctx.fillStyle = '#e74c3c';
             ctx.beginPath();
             const centerX = food.x * gridSize + gridSize / 2;
             const centerY = food.y * gridSize + gridSize / 2;
             const radius = gridSize / 2 - 2;
             ctx.arc(centerX, centerY, radius, 0, Math.PI * 2);
             ctx.fill();
         }
 ​
         // 更新游戏状态
         function updateGame() {
             if (!gameRunning) return;
 ​
             // 移动蛇
             const head = {x: snake[0].x + dx, y: snake[0].y + dy};
 ​
             // 检查墙壁碰撞
             if (head.x < 0 || head.x >= tileCount || head.y < 0 || head.y >= tileCount) {
                 endGame();
                 return;
             }
 ​
             // 检查自身碰撞
             if (snake.some(segment => segment.x === head.x && segment.y === head.y)) {
                 endGame();
                 return;
             }
 ​
             // 添加新的头部
             snake.unshift(head);
 ​
             // 检查是否吃到食物
             if (head.x === food.x && head.y === food.y) {
                 score += 10;
                 scoreElement.textContent = score;
                 
                 // 每得50分加速一次
                 if (score % 50 === 0 && gameSpeed > 50) {
                     gameSpeed -= 10;
                 }
                 
                 randomFood();
             } else {
                 // 没吃到食物,移除尾部
                 snake.pop();
             }
 ​
             drawGame();
         }
 ​
         // 结束游戏
         function endGame() {
             gameRunning = false;
             gameOverElement.style.display = 'block';
             gameOverElement.textContent = `游戏结束! 最终得分: ${score} 按空格键重新开始`;
         }
 ​
         // 重置游戏
         function resetGame() {
             initGame();
             gameSpeed = 120;
             drawGame();
         }
 ​
         // 键盘控制
         function changeDirection(event) {
             // 防止页面滚动
             if([32, 37, 38, 39, 40].indexOf(event.keyCode) > -1) {
                 event.preventDefault();
             }
 ​
             // 空格键重新开始
             if (event.keyCode === 32 && !gameRunning) {
                 resetGame();
                 return;
             }
 ​
             if (!gameRunning) return;
 ​
             const keyPressed = event.keyCode;
             const goingUp = dy === -1;
             const goingDown = dy === 1;
             const goingRight = dx === 1;
             const goingLeft = dx === -1;
 ​
             switch(keyPressed) {
                 case 37: // 左箭头
                     if (!goingRight) {
                         dx = -1;
                         dy = 0;
                     }
                     break;
                 case 38: // 上箭头
                     if (!goingDown) {
                         dx = 0;
                         dy = -1;
                     }
                     break;
                 case 39: // 右箭头
                     if (!goingLeft) {
                         dx = 1;
                         dy = 0;
                     }
                     break;
                 case 40: // 下箭头
                     if (!goingUp) {
                         dx = 0;
                         dy = 1;
                     }
                     break;
             }
         }
 ​
         // 触摸控制(移动设备)
         let touchStartX = 0;
         let touchStartY = 0;
 ​
         function handleTouchStart(event) {
             touchStartX = event.touches[0].clientX;
             touchStartY = event.touches[0].clientY;
         }
 ​
         function handleTouchMove(event) {
             if (!touchStartX || !touchStartY || !gameRunning) return;
 ​
             const touchEndX = event.touches[0].clientX;
             const touchEndY = event.touches[0].clientY;
 ​
             const dxTouch = touchEndX - touchStartX;
             const dyTouch = touchEndY - touchStartY;
 ​
             // 确定主要滑动方向
             if (Math.abs(dxTouch) > Math.abs(dyTouch)) {
                 // 水平滑动
                 if (dxTouch > 0 && dx !== -1) {
                     // 向右
                     dx = 1;
                     dy = 0;
                 } else if (dxTouch < 0 && dx !== 1) {
                     // 向左
                     dx = -1;
                     dy = 0;
                 }
             } else {
                 // 垂直滑动
                 if (dyTouch > 0 && dy !== -1) {
                     // 向下
                     dx = 0;
                     dy = 1;
                 } else if (dyTouch < 0 && dy !== 1) {
                     // 向上
                     dx = 0;
                     dy = -1;
                 }
             }
 ​
             touchStartX = null;
             touchStartY = null;
         }
 ​
         // 事件监听
         document.addEventListener('keydown', changeDirection);
         canvas.addEventListener('touchstart', handleTouchStart, false);
         canvas.addEventListener('touchmove', handleTouchMove, false);
 ​
         // 防止移动端页面滚动
         document.body.addEventListener('touchmove', function(event) {
             if (event.target === canvas) {
                 event.preventDefault();
             }
         }, false);
 ​
         // 启动游戏
         initGame();
         drawGame();
         
         // 游戏主循环
         setInterval(updateGame, gameSpeed);
     </script>
 </body>
 </html>
 ------------------------------------------------------------------
 #3. 创建Dockerfile
 vim Dockerfile
 ---------------------------------------------------
 FROM nginx:alpine
 COPY index.html /usr/share/nginx/html/index.html
 COPY default.conf /etc/nginx/conf.d/default.conf
 EXPOSE 80
 CMD ["nginx", "-g", "daemon off;"]
 ---------------------------------------------------
 #4. 创建Nginx配置
 vim default.conf
 ---------------------------------------------------
 server {
     listen 80;
     server_name localhost;
     root /usr/share/nginx/html;
     index index.html;
 ​
     location / {
         try_files $uri $uri/ =404;
     }
 }
 ---------------------------------------------------
 #5. 构建和运行
 docker build -t snake-game .
 docker run -d --name snake -p 8081:80 snake-game

实例4:使用Dockerfile制作Redis镜像

 # 1. 创建项目目录
 mkdir -p /data/dockerfile/redis
 cd /data/dockerfile/redis
 # 2. 创建Dockerfile
 vim Dockerfile
 内容如下:
 # 使用官方Redis镜像
 FROM redis:7.2-alpine
 # 设置时区(可选)
 ENV TZ=Asia/Shanghai
 # 复制自定义配置文件
 COPY redis.conf /usr/local/etc/redis/redis.conf
 # 暴露端口
 EXPOSE 6379
 # 使用自定义配置启动Redis
 CMD ["redis-server", "/usr/local/etc/redis/redis.conf"]
 # 3. 创建Redis配置文件
 vim redis.conf
 内容如下:
 # Redis基础配置
 bind 0.0.0.0
 port 6379
 # 安全设置
 requirepass redis123
 # 持久化设置
 save 900 1
 save 300 10
 save 60 10000
 # 内存设置
 maxmemory 256mb
 maxmemory-policy allkeys-lru
 # 日志设置
 loglevel notice
 logfile ""
 # 网络设置
 tcp-keepalive 300
 # 性能调优
 timeout 0
 tcp-backlog 511
 databases 16
 # 4. 构建镜像
 # 构建Redis镜像
 docker build -t redis-custom .
 # 查看构建的镜像
 docker images
 # 5. 运行容器
 # 运行Redis容器
 docker run -d \
   --name redis-server \
   -p 6379:6379 \
   -v redis_data:/data \
   redis-custom
 6. 验证连接
 # 进入Redis CLI
 docker exec -it redis-server redis-cli -a redis123(没设密码就不用-a)
 # 或者分步连接
 docker exec -it redis-server redis-cli
 127.0.0.1:6379> AUTH redis123
 127.0.0.1:6379> PING
 7. Redis基本操作测试
 # 测试Redis功能
 # 在Redis CLI中执行:
 127.0.0.1:6379> ping            # 测试连接
 PONG
 127.0.0.1:6379> SET mykey "Hello Redis"
 127.0.0.1:6379> GET mykey
 127.0.0.1:6379> INFO server      # 查看Redis信息
 127.0.0.1:6379> EXIT

实例5:使用Dockerfile制作MySQL镜像

 # 1.创建项目目录和文件
 mkdir -p /data/dockerfile/mysql
 cd /data/dockerfile/mysql
 # 2.创建Dockerfile
 vim Dockerfile
 ---------------------------------------------------
 内容如下:
 # Dockerfile
 FROM mysql:8.0.20
 # 设置环境变量
 ENV MYSQL_ROOT_PASSWORD=root123
 ENV MYSQL_DATABASE=test
 ENV MYSQL_USER=root
 # 暴露端口
 EXPOSE 3306
 # 使用官方镜像的入口点
 CMD ["mysqld"]
 ---------------------------------------------------
 # 3.构建自定义镜像并查看镜像
 docker build -t mysql-8.0.20-custom:8.0.20 .
 docker images
 # 4.运行容器
 docker run -d --name mysql-8.0.20 -p 3306:3306 -v mysql_data:/var/lib/mysql mysql-8.0.20-custom:8.0.20
 # 5.进入MySQL验证连接
 docker exec -it mysql-8.0.20 mysql -uroot -proot123
 ========================================================================
 补充内容:
 使用docker-compose(推荐)
 # 创建 docker-compose.yml 文件:
 version: '3.8'
 services:
   mysql:
     build: .
     container_name: mysql-8.0.20
     environment:
       MYSQL_ROOT_PASSWORD: root123
       MYSQL_DATABASE: default_db
     ports:
       - "3306:3306"
     volumes:
       - mysql_data:/var/lib/mysql
       - ./my.cnf:/etc/mysql/conf.d/my.cnf
     restart: unless-stopped
 volumes:
   mysql_data:
 # 安装docker-compose并运行  # version 1.29.2-1
 apt install docker-compose
 docker-compose up -d
 --------------------------------------
 # 如果中间出错可以删了重新构建
 # ①删除现有镜像
 docker rmi mysql-8.0.20-custom:latest
 # 重新构建并指定版本标签
 docker build -t mysql-8.0.20-custom:8.0.20 .
 # 查看镜像
 docker images
 ##或者
 # ②重置数据卷(如果之前删除过旧的数据)
 # 删除旧数据卷
 docker stop mysql-8.0.20
 docker rm mysql-8.0.20
 docker volume rm mysql_data
 # 重新运行
 docker run -d --name mysql-8.0.20 -p 3306:3306 -v mysql_data:/var/lib/mysql mysql-8.0.20-custom:8.0.20

Dockerfile镜像部署 一、环境部署 构建SSH镜像 创建镜像目录方便管理 1、关闭防火墙 [root@localhost ~]# systemctl status firewalld.service ● firewalld.service - firewalld - dynamic firewall daemon Loaded: loaded (/usr/lib/systemd/system/firewalld.service; disabled; vendor preset: enabled) Active: in 阅读详情

相关推荐

Docker使用及部署流程

Docker的使用及部署的具体流程

FFFPAG的博客 2095

Docker概述、部署、镜像与容器管理

Docker是一个开源的应用容器引擎,基于go语言开发并遵循了apache2.0协议开源。Docker是在Linux容器里运行应用的开源工具,是一种轻量级的“虚拟机”。Docker 的容器技术可以在一台主机上轻松为任何应用创建一个轻量级的、可移植的、自给自足的容器。infodocker镜像操作docker search 仓库/镜像的关键词pull 仓库名/镜像名:标签 #如果不指定标签默认使用 :latest 标签imagestags 旧镜像名:旧标签 新镜像名:新标签。

fyb012811的博客 1687

【Docker系列】Dockerfile基础

Dockerfile dockerfile用来构建docker镜像的文件!是一种命令参数脚本! 构建步骤 1、编写一个dockerfile文件 2、docker build构建成一个镜像 3、docker run 运行镜像 4、docker push 发布镜像(DockerHub、阿里云镜像仓库、私服) Dockerfile的构建过程 基础知识 1、每个保留关键字(指令)都是大写字母 2、指令从上到下顺序执行 3、#表示注释 4、每一个指令都会创建提交一个新的镜像层,并提交! dockerfile是面向开

自律即是最自由 253

docker构建镜像及项目部署

如果我要部署一个Java项目,把它打包为一个镜像该怎么做呢?要想自己构建镜像,必须先了解镜像的结构。镜像之所以能让我们快速跨操作系统部署应用而忽略其运行环境、配置,就是因为镜像中包含了程序运行需要的系统函数库、环境、配置、依赖。因此,自定义镜像本质就是依次准备好程序运行的基础环境、依赖、应用本身、运行配置等文件,并且打包而成。准备一个linux服务(CentOS或者Ubuntu均可),java项目并不需要完整的操作系统,仅仅是基础运行环境即可;这一步保证了即使镜像所处操作系统不同,镜像还是能够使用;

packge的博客 1569

Dockerfile+jar制作镜像部署jar项目

准备工作 1、安装有Docker的服务器(服务器Docker安装) 2、项目jar包(本项文项目以springboot jar为例) 3、将jar包上传到服务器中 Dockerfile文件编写 1、在jar包通目录下通过命令vim Dockerfile 新建Dockerfile 2、在Dockerfile中写入如下内容 FROM openjdk:8-jdk-alpine VOLUME /tmp ADD docker.jar app.jar ENTRYPOINT ["java","-Djava.securit

metgo的博客 6023

Java分布式流处理,flink+kafka实现电商网站个性化商品推荐系统

在现代电商环境中,用户每天都会浏览大量商品页面,而这些行为数据中蕴藏着丰富的信息。通过分析用户的浏览历史、购买记录以及对特定商品的兴趣程度,我们可以为用户提供更加个性化的商品推荐,从而提升用户体验和转化率。为了实现实时的个性化推荐,我们需要构建一个能够快速处理并响应用户行为变化的数据处理管道。

横竖撇折点 2144

DockerFile

DockerFile DockerFile是用来构建Docker镜像的文本文件,是由一条构建镜像所需的指令和参数构成的脚本。 官网 构建三步骤: 编写DockerFile文件 docker build命令构建镜像 docker run以镜像运行容器实例 1、DockerFile构建过程解析 DockerFile内容基础知识: 1. 每条保留字指令都必须为大写字母且后面都要跟随至少一个参数。 2. 指令按照从上到下,顺序执行。 3. #表示注释。 4. 每条指令都会创建一个新的镜像层并对镜像进行提交。 D

weixin_44142888的博客 1302

Unity3D赛车游戏+脚本基础

本章主要介绍Unity的基础开发流程以及涉及到的概念。这个过程需要我们学会编写一些游戏脚本,在这讲的过程中我们会完成一个赛车小游戏,因此,在讲述这些基本概念和流程的时候,会同时涉及到一点脚本的开发基础.在游戏,电影和动画中,都有一个渲染的帧率,电影是24帧/s,游戏大概是30帧/s(当然也有60帧/s的)。在unity里面1秒钟,Update方法执行了30次。1秒钟有30帧,帧与帧之所消耗的时间是不一样的,那么我如何知道上一帧用了多少时间?Time.deltaTime就是为了解决这个问题。

m0_58367586的博客 7657

docker系列:dockerfile及其用法解析

本文介绍Dockerflile及其用法。

jclee95的个人博客 445

Claude Code教程(二) | Claude Code 核心信息与使用指南

Claude Code 核心信息与使用指南

qq_20236937的博客 2182

Stata面板数据OLS回归分析实战指南

OLS回归作为计量经济学的核心分析方法,通过最小化残差平方和实现参数估计,广泛应用于经济学实证研究。其技术价值在于模型简洁、结果易于解释,特别适合处理面板数据中的复杂关系。在实际应用中,配合robust标准误能有效解决异方差问题,而固定效应模型则可控制个体特异性。本文以Stata软件为例,详细演示从数据导入、描述性统计到混合OLS和固定效应模型构建的全流程,重点解析面板数据特有的格式设定、模型选择标准以及结果呈现技巧,为经济学研究者提供可直接复用的分析框架。

weixin_29051811的博客 268

dockerfile

dockerfile一、什么是Dockerfile二、Dockerfile的基本结构1、基础镜像信息2、维护者信息3、镜像操作指令4、容器启动时执行指令三、使用Dockerfile基于centos创建JDK8的镜像1.创建文件夹上传jdk的安装包,和在同级目录下编写Dockerfile文件2.编写 Dockerfile 文件(重要)3.执行Dockerfile文件,构建jdk8的镜像4.查看镜像5.创建并启动容器6.进入容器7.检查是否有问题四、基于最小的操作系统Alpine的镜像构建容器五、总结 一、什么

小七 1221

手把手用ROS实现Ego-Planner动态避障:无人机撞树问题终结方案

本文详细介绍了如何在ROS和Gazebo仿真环境中,通过配置和调优Ego-Planner算法,实现无人机的动态避障功能。文章深入解析了其基于局部梯度优化的核心思想,提供了从环境搭建、参数详解到代码集成的完整实践指南,并分享了实战排错经验,旨在彻底解决无人机在复杂动态场景中的碰撞问题。

weixin_29031161的博客 1625

docker-Dockerfile基础知识

当指定了ENTRYPOINT后,CMD的含义就发生变化,不再直接运行命令而是将CMD的内容作为参数传递给ENTRYPOINT命令,二者组合变成 “”按照官方文档的描述,可以使用LABEL maintainer=“xxx” 代替maintainer xxx 需要注意的是两者设置的值,在镜像的描述文件中所处的位置是不一样的。基础镜像,当前新镜像是基于哪个镜像的,指定一个以及存在的镜像作为模板,第一条必须是FROM。指定该镜像以什么样的用户去执行,如果不指定,默认是root。

慕雪的博客 1127

【EDA Tools】Spyglass 检查 Verilog 和 SystemVerilog 混合语言及 Lint 检查

Spyglass可以用于检查混合设计中的语言互操作性和一致性问题。对于设计中包含多种硬件描述语言的情况,Spyglass 能够识别并解析其中的模块及其互连,并对其进行验证。例如,在包含 Verilog 和 VHDL 的混合设计中,Spyglass 会自动识别并解析 Verilog 和 VHDL 文件及其相互连接。通过运行 Spyglass Lint 功能,可以检查混合设计中的语言一致性问题,例如不兼容的数据类型、互操作性问题以及其他可能导致设计故障或不一致的问题。

记录学习历程 5078

【占用网络】OccNet: Scene as Occupancy 适用于检测、分割和规划任务 ICCV2023

本文分享“占用网络”方案中,具有代表性的方法:OccNet。它以多视角视觉为核心,首先生成BEV特征,然后通过级联结构和时间体素解码器重建生成3D占用特征。构建一个通用的“3D占用编码特征”,用以表示3D物理世界。这样的特征描述可以应用于广泛的自动驾驶任务,包括检测、分割和规划。

黎国溥 3360

Dockerfile制作httpd镜像

Dockerfile制作httpd镜像

m0_53765226的博客 449

SAP-ABAP:SAP HANA性能神器FDA:是极速查询的引擎,也是CPU过载的元凶

在SAP S/4HANA的世界里,有一个被ABAP开发者们既爱又怕的特性——Fast Data Access(FDA),它能将性能提升百倍,也能让CPU瞬间飙升。本文将带您全面解剖这一核心机制。

baidu_35680696的博客 847

Docker-第六课,DockerFile

Docker介绍 dockerFile使用来构建docker镜像的文件!命令参数脚本! 构建步骤; 1、编写一个dockerfile文件 2、docker build 构建成为一个镜像 3、docker run 运行镜像 4、docker push 发布镜像(DockerHub 、阿里云镜像仓库) 很多官方镜像都是基础包,很多功能没有,我们通常会搭建自己的镜像! DockerFile 构建过程 基础知识: 1、每个保留关键字(指令)都必须是大写字母 2、执行从上到下的执行 3、# 表示注释 4、每个指令

weixin_42997698的博客 198

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

在docker中部署tomcat并且部署java应用程序的步骤详解

作者:坐忘峰 字体:[增加 减小] 类型:转载 时间:2016-10-08 我要评论 本文给大家介绍如何在docker中部署tomcat及如何部署我们的应用程序到docker容器的tomcat里,本文介绍的非常详细,具有参考借鉴价值,一起看看吧 先给大家简单说下Docker的概念 Docker 是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依

飞奔的小土豆@1024 5765

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Docker构建自定义的镜像

构建自定义的 Docker 镜像是 Docker 使用中的核心操作之一。通过自定义镜像,你可以将应用程序及其依赖环境打包成一个可移植的容器化镜像。以下是详细的步骤和注意事项:1. 准备工作在构建自定义镜像之前,你需要准备以下内容:Dockerfile:这是构建镜像的核心文件,定义了镜像的构建步骤。应用程序代码:你的应用程序代码及相关文件。依赖文件(可选):如 requirements.txt(Python)、pom.xml(Java)等。2. 编写 Dockerfile。

lijunwusino的博客 719

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Dockerfile学习小结

学习pinpoint的时候对Dockerfile有了更好的认识,趁热打铁赶紧总结。 #基础镜像,镜像基于这个jdk来打镜像

weixin_53709630的博客 1349

使用Dockerfile打包java项目生成镜像部署到Linux

如果说容器就是“小板房”,镜像就是“样板间”。那么,要造出这个“样板间”,就必然要有一个“施工图纸”,由它来规定如何建造地基、铺设水电、开窗搭门等动作。这个“施工图纸”就是“Dockerfile”。比起容器、镜像来说,Dockerfile非常普通,它就是一个纯文本,里面记录了一系列的构建指令,比如选择基础镜像、拷贝文件、运行脚本等等,每个指令都会生成一个 Layer,而 Docker 顺序执行这个文件里的所有步骤,最后就会创建出一个新的镜像出来。

FLGB 2562

【docker】Dockerfile自定义镜像

常见的镜像在DockerHub就能找到,但是我们自己写的项目就必须自己构建镜像了。而要自定义镜像,就必须先了解镜像的结构才行。

m0_62645012的博客 1728

DockerFile定制镜像

Dockerfile 是⼀个⽤来构建镜像的⽂本⽂件,⽂本内容包含了⼀条条构建镜像所需的指令和 说明,每条指令构建⼀层,最终构建出⼀个新的镜像。docker镜像的本质是⼀个分层的⽂件系统centos的iso镜像⽂件是包含bootfs和rootfs及⼤量软件包,⽽docker的centos镜像复 ⽤了操作系统的bootfs,也没有⼤量软件包,只有rootfs和其他必要镜像层。

WWNY666的博客 1410

Dockerfile 构建java镜像并运行部署java项目

Dockerfile是一个文本文件,它包含了用于构建 Docker 镜像的一系列指令。通过dockerfile,你可以定义应用程序的运行环境,包括操作系统、依赖库、配置文件以及启动命令等。这使得 Docker 镜像可以被一致地构建和部署,确保了开发、测试和生产环境之间的兼容性。通俗点来讲,Dockerfile 就像是一份“食谱”,它告诉 Docker 如何一步一步地准备一个特定的运行环境。想象一下,你想要制作一款特别的蛋糕。你需要知道:用什么材料(比如面粉、鸡蛋、糖)。

qq_58195504的博客 2505
上一篇: Docker容器化
下一篇: Docker Compose、私有镜像站和Swam集群
chen_note
博客等级 码龄1年 251粉丝 83原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值