需要关注持续更新的朋友可以关注下面的链接：运维相关合集地址

线下服务部署上线的几种方式

以一个 java 打包的 jar 为例

环境配置

这里是 jar，需要 jdk 环境才能运行，如果是 python 程序，则需要 python 的环境，以此类推。

简单运行

java -jar A.jar

使用 nohup 后台执行

要将命令的输出结果重定向到文件，同时在后台运行，可以结合使用 nohup 和输出重定向符号 > 或 >>。下面是具体的执行步骤：

1. 打开终端或登录到远程 Linux 服务器。

2. 使用以下命令执行命令，并将输出结果重定向到文件：

nohup your_command > output.log &

在这个命令中，your_command 是你要在后台运行的命令，output.log 是你希望将输出结果保存的文件名。

如果你希望将输出结果追加到现有文件而不是覆盖文件内容，可以使用 >>：

nohup your_command >> output.log &

3. 执行命令后，会显示一个进程号（PID），表示命令正在后台运行。你可以关闭终端或在其他任务上继续工作，命令会继续在后台运行。

4. 如果你想查看命令的输出或确认命令是否在后台运行，可以使用 tail 命令来查看输出文件的内容：

tail -f output.log

这将实时显示文件的最后几行内容，方便你跟踪命令的输出。

通过使用 nohup 和输出重定向，你可以在后台运行命令，并将输出结果保存到指定的文件中，而不会受到终端关闭或断开连接的影响。

在 Linux 系统中，& 符号用于将命令放入后台运行。当你在终端中执行一个命令，并在命令结尾添加 & 符号时，该命令将在后台运行，而不会阻塞终端，允许你继续输入其他命令或关闭终端。

具体来说，& 的作用是将命令置于后台执行，并立即返回终端提示符，以便你可以继续输入其他命令。这对于长时间运行的命令或需要与终端交互的命令很有用。使用 & 后，你可以在后台运行命令，同时继续使用终端进行其他操作，而不必等待命令完成。

例如，假设你有一个需要较长时间运行的命令，如数据处理、备份或程序编译等，可以使用 & 将其放入后台运行：

your_command &

当命令开始在后台运行时，会显示一个进程号（PID），用于标识该后台进程。你可以使用其他命令（如 ps、top、htop）来查看进程的状态和输出。

需要注意的是，当命令在后台运行时，它的输出默认会在终端中显示。如果你希望将输出保存到文件中，可以使用输出重定向符号 > 或 >> 将输出重定向到指定的文件中，如前面所述。

如果你想要忽略命令的输出，可以使用 /dev/null。/dev/null 是一个特殊的设备文件，在 Linux 系统中被用作一个空设备，所有写入它的数据都会被丢弃，而读取它则会立即返回空。

你可以使用输出重定向符号 > 或 >> 将命令的输出重定向到 /dev/null，这样输出将被丢弃而不会在终端显示，例如：

your_command > /dev/null

或者

your_command >> /dev/null

第一个命令将命令的标准输出重定向到 /dev/null，而第二个命令使用 >> 以追加的方式将标准输出重定向到 /dev/null。这样，命令的输出将完全被忽略。

同时，你也可以将标准错误输出重定向到 /dev/null，以防止错误信息在终端中显示：

your_command 2> /dev/null

这将将命令的标准错误输出重定向到 /dev/null，而保留标准输出在终端显示。

使用 /dev/null 可以有效地忽略命令的输出，适用于不需要关心输出结果的情况，或者当你不想在终端上看到命令输出时。

编写执行脚本

当执行的脚本比较长时，可以考虑将执行的命令放到一个 shell 脚本中，这里面有两种方式，第一种是直接放入，然后将多条命令用 && 连接起来。第二种是真正意义上的 shell 脚本

将多条指令使用 && 连接起来的方式与将命令直接写在脚本中有以下区别：

1. 多条指令使用 && 连接：当你在脚本中使用多条指令，并使用 && 连接它们时，表示只有前一条指令成功执行（即返回状态码为 0），才会执行下一条指令。如果前一条指令失败（返回状态码非零），则后续的指令将不会执行。这种方式可以确保每条指令在满足条件的情况下才执行，提高脚本的健壮性。

例如：

#!/bin/bashcommand1 && command2 && command3

在这个脚本中，只有在 command1 执行成功后，才会继续执行 command2，并且只有在 command2 执行成功后，才会继续执行 command3。如果其中任何一条指令失败，后续指令将不会执行。

2. 直接写在脚本中：如果你将命令直接写在脚本中，每个命令将按顺序执行，而无论前面的命令是否成功。这种方式适用于你希望无论前面的命令结果如何，都继续执行后续的命令。

例如：

#!/bin/bashcommand1command2command3

在这个脚本中，command1 会被执行，无论其执行结果如何，然后会执行 command2，再执行 command3。

总结：使用 && 连接多条指令可以在一定程度上提高脚本的健壮性，确保只有前一条指令成功后才继续执行后续指令。而将命令直接写在脚本中，则会按照顺序依次执行每个命令，不考虑前一条命令的执行结果。具体使用哪种方式取决于你的需求和脚本逻辑。

使用 screen 命令

简单用法

screen 命令可以在部署应用程序时非常有用。它允许你在一个终端会话中创建多个虚拟终端，并在这些终端之间切换。这对于在服务器上运行应用程序时特别有用，因为它可以让你在后台运行应用程序并随时访问它。

使用 screen 命令进行部署的一般步骤如下：

1. 打开终端或登录到远程 Linux 服务器。

2. 运行 screen 命令来创建一个新的screen会话：

screen

3. 在 screen 会话中执行应用程序的命令。例如，运行 Java JAR 文件：

java -jar your.jar

4. 按下组合键 Ctrl+a，然后按下 d 键（即先按下 Ctrl+a，再松开，然后按下 d）来分离 screen 会话。这将使 screen 会话在后台继续运行应用程序，而你返回到原始终端。

5. 如果需要重新连接到 screen 会话，可以使用以下命令：

screen -r

这会将你重新连接到之前创建的 screen 会话，你可以继续与应用程序交互。

使用 screen 命令可以保持应用程序在后台运行，并允许你在需要时重新连接到会话，查看应用程序的输出或进行其他操作。这在部署长时间运行的应用程序或需要定期检查应用程序状态的情况下非常有用。请注意，在关闭终端或断开连接时，screen 会话仍然保持活动状态。

可选参数

screen 命令有许多选项，用于控制创建和管理 screen 会话的行为。以下是一些常用的选项：

• -S session_name：指定会话的名称。可以使用该名称来重新连接到特定的 screen 会话。

• -r session_name：重新连接到指定名称的 screen 会话。

• -d session_name：分离指定名称的 screen 会话。

• -ls：列出当前存在的 screen 会话。

• -L：启用日志记录。将会话输出写入当前目录下的 screenlog.n 文件中（n 是会话编号）。

• -X：向会话发送命令。可以使用 -X 选项执行与 screen 会话相关的命令，如发送键盘输入、关闭会话等。

在使用这些选项时，需要注意以下几点：

• session_name 是自定义的会话名称。通过指定不同的名称，你可以创建多个 screen 会话并进行区分。

• 如果只有一个 screen 会话存在，可以省略 -S session_name 选项。screen -r 将自动连接到唯一的会话。

• 如果有多个会话，可以通过 screen -ls 列出当前存在的会话，并查看它们的名称和状态。

• 在 screen 会话中，使用组合键 Ctrl+a，然后按下 ? 键，可以查看更多帮助和可用的命令。

这些选项可以帮助你更好地管理和操作 screen 会话。你可以根据需求选择适当的选项来创建、连接、分离和管理 screen 会话。

系统服务化

使用步骤

要利用系统服务（Systemd）来部署自己的 JAR 文件，可以按照以下步骤进行操作：

1. 创建一个 Systemd 服务单元文件：

   sudo nano /etc/systemd/system/myapp.service

2. 在打开的文件中，输入以下内容：

   [Unit]   Description=My App Service   After=network.target
   [Service]   User=your_username   WorkingDirectory=/path/to/your/app   ExecStart=/usr/bin/java -jar your.jar   Restart=always   RestartSec=10   SuccessExitStatus=143
   [Install]   WantedBy=multi-user.target

• Description：描述服务的简要说明。

• User：指定服务运行的用户名。

• WorkingDirectory：设置工作目录，即 JAR 文件所在的路径。

• ExecStart：指定要执行的命令，即启动 JAR 文件。

• Restart：设置服务在意外退出后自动重启。

• RestartSec：设置重启之间的延迟时间。

• SuccessExitStatus：设置成功退出的状态码。

请将上述内容根据你的实际情况进行修改。

3. 保存并关闭文件。

4. 重新加载 Systemd 配置：

   sudo systemctl daemon-reload

5. 启动服务：

   sudo systemctl start myapp

现在，你的 JAR 文件将在后台作为一个系统服务运行。

6. 可选：设置开机自启动服务：

   sudo systemctl enable myapp

这样，服务将在系统启动时自动启动。

你现在可以使用 Systemd 来管理你的 JAR 文件。以下是一些常用的 Systemd 命令：

• 启动服务：

  sudo systemctl start myapp

• 停止服务：

  sudo systemctl stop myapp

• 重启服务：

  sudo systemctl restart myapp

• 查看服务状态：

  sudo systemctl status myapp

• 关闭服务：

  sudo systemctl disable myapp

这样，你可以方便地使用 Systemd 来管理你的 JAR 文件，并确保它在系统启动时自动运行，并具有自动重启的功能。

监控服务日志

要对系统服务的日志进行监控，可以使用 Systemd Journal，它是 Systemd 的日志记录工具。Systemd Journal 可以轻松地访问和监控系统服务的日志信息。

以下是一些常用的 Systemd Journal 监控命令：

1. 查看特定服务的日志：

   journalctl -u service_name

将 service_name 替换为你要监控的服务的名称。这将显示该服务的日志信息。

2. 查看最新的日志条目：

   journalctl -xe

这将显示最近的系统日志条目，包括错误和警告。

3. 持续监控日志：

   journalctl -f

这将实时显示系统日志的更新，类似于 tail -f 命令。

4. 根据时间范围过滤日志：

   journalctl --since "2023-06-01" --until "2023-06-08"

使用 --since 和 --until 参数指定起始和结束时间，以筛选特定时间范围内的日志。

5. 根据关键字过滤日志：

   journalctl -u service_name --grep "keyword"

使用 --grep 参数过滤包含指定关键字的日志条目。

这些命令可以帮助你监控系统服务的日志信息。你可以根据需要进行过滤、搜索和持续监视日志，以了解服务的运行情况和故障排查。有关更多可用选项和命令，请参阅 journalctl 的文档（man journalctl）。

使用 docker 部署

使用步骤

要使用 Docker 部署自己的服务，可以按照以下步骤进行操作：

1. 准备 Docker 镜像：

2. 创建一个 Dockerfile，定义你的服务所需的环境和依赖项。

3. 在 Dockerfile 中指定要运行的命令或启动脚本。

4. 构建 Docker 镜像，使用以下命令：

     docker build -t your_image_name .

 这将在当前目录下构建 Docker 镜像。

2. 运行 Docker 容器：

3. 使用以下命令来运行 Docker 容器：

     docker run -d --name your_container_name -p host_port:container_port your_image_name

 - `your_container_name` 是你为容器指定的名称。 - `host_port` 是你希望在主机上映射的端口号。 - `container_port` 是容器内服务实际运行的端口号。 - `your_image_name` 是之前构建的 Docker 镜像的名称。

• 如果服务需要访问外部存储或文件，你可以使用 Docker 卷进行挂载，以便在容器内部访问它们。

3. 验证服务：

4. 使用容器运行的服务的主机端口访问服务，例如：http://localhost:host_port。

5. 确保服务正常运行并按预期工作。

通过这些步骤，你可以使用 Docker 构建镜像并运行容器来部署你的自定义服务。Docker 提供了一种轻量级、可移植和可扩展的方式来封装和分发应用程序，使其易于部署和管理。

利用 dockerfile 部署

编写 Dockerfile 是定义 Docker 镜像构建过程的关键。以下是编写 Dockerfile 的一般步骤：

1. 选择基础镜像：在 Dockerfile 中，首先需要指定基础镜像。基础镜像是你构建镜像的起点，它包含了操作系统和基本环境。你可以选择根据你的需求选择适合的基础镜像，例如 ubuntu, alpine, centos 等。

2. 示例：

   FROM ubuntu:latest

2. 安装依赖项：根据你的应用程序或服务所需的依赖项，在 Dockerfile 中安装它们。这可以包括软件包、库文件、工具等。

3. 示例：

   RUN apt-get update && apt-get install -y \       software-package1 \       software-package2

3. 添加应用程序文件：将你的应用程序文件复制到 Docker 镜像中。这可以包括可执行文件、配置文件、静态文件等。

4. 示例：

   COPY app.jar /app/app.jar   COPY config.yml /app/config.yml

4. 设置工作目录：在镜像中设置一个工作目录，即在容器内运行命令的默认目录。

5. 示例：

   WORKDIR /app

5. 暴露端口：如果你的应用程序需要在容器外部访问端口，可以使用 EXPOSE 命令来指定要暴露的端口号。

6. 示例：

   EXPOSE 8080

6. 定义启动命令：最后，使用 CMD 或 ENTRYPOINT 命令指定容器启动时要运行的命令。

7. 示例：

   CMD ["java", "-jar", "/app/app.jar"]

编写完 Dockerfile 后，可以使用以下命令构建 Docker 镜像：

docker build -t your_image_name .

其中，your_image_name 是你为镜像指定的名称。

这只是一个简单的示例，你可以根据你的应用程序和需求自定义 Dockerfile 的内容。在编写 Dockerfile 时，建议参考 Docker 官方文档和最佳实践，以确保构建出高效、可靠和安全的镜像。

利用 docker 打包成 docker 镜像从本地加载

有时候需要将应用程序打包成 Docker 镜像并从本地加载，原因如下：

1. 简化部署：将应用程序打包成 Docker 镜像可以将应用程序及其依赖项捆绑在一起，形成一个独立的、可移植的部署单元。这样，你可以将镜像轻松地在不同的环境中部署，无需手动安装和配置应用程序的依赖项。

2. 一致性：通过将应用程序打包成 Docker 镜像，确保在不同的环境中运行相同的容器，从而保持环境一致性。这消除了开发、测试和生产环境之间的差异，减少了由于环境差异引起的问题。

3. 隔离性：Docker 镜像提供了隔离的运行环境，使应用程序与主机系统隔离开来。这样，即使应用程序在容器内部具有不同的依赖项或运行时环境，也不会与主机系统或其他应用程序产生冲突。

4. 管理依赖项：通过使用 Docker 镜像，可以明确指定应用程序所需的依赖项和版本，从而避免依赖项冲突或版本不兼容的问题。这使得应用程序的构建和部署过程更加可靠和可重复。

5. 快速交付：将应用程序打包成 Docker 镜像后，可以轻松地将镜像传递给其他开发人员、测试团队或部署团队。这样，团队成员可以快速获取镜像，并在本地加载和运行它，而无需关心环境配置和依赖项安装。

通过将应用程序打包成 Docker 镜像并从本地加载，你可以获得许多便利性和优势，包括简化部署流程、保持一致性、提供隔离性、管理依赖项以及实现快速交付。这是为什么 Docker 在开发和部署应用程序中越来越受欢迎的原因之一。

要将应用程序打包成 Docker 镜像并从本地加载，可以按照以下步骤进行操作：

1. 编写 Dockerfile：创建一个名为 Dockerfile 的文本文件，其中包含构建 Docker 镜像所需的指令和配置。

2. 在 Dockerfile 中定义基础镜像：选择适合你的应用程序的基础镜像，例如 ubuntu, alpine, centos 等。

3. 示例：

   FROM ubuntu:latest

3. 将应用程序添加到镜像中：使用 COPY 命令将应用程序的文件复制到镜像中的指定目录。

4. 示例：

   COPY app.jar /app/app.jar   COPY config.yml /app/config.yml

4. 定义镜像的工作目录：使用 WORKDIR 命令设置镜像中的工作目录。

5. 示例：

   WORKDIR /app

5. 构建 Docker 镜像：使用 docker build 命令构建 Docker 镜像。

   docker build -t your_image_name .

这将在当前目录下构建 Docker 镜像，并为镜像指定一个名称（your_image_name）。

6. 加载镜像：使用 docker load 命令从本地加载镜像。

   docker load -i your_image.tar

这将从的本地文件系统加载 Docker 镜像。请确保将 your_image.tar 替换为你实际的镜像文件的路径。

7. 验证镜像是否加载成功：使用 docker images 命令查看已加载的镜像列表。

   docker images

如果看到刚刚加载的镜像，说明加载成功。

现在，已经成功地将应用程序打包成 Docker 镜像，并从本地加载到 Docker 环境中。可以使用 docker run 命令来运行该镜像，并在容器中启动你的应用程序。

docker run -d --name your_container_name -p host_port:container_port your_image_name

将 your_container_name 替换为容器指定的名称，host_port 替换为你希望在主机上映射的端口号，container_port 替换为容器内应用程序实际运行的端口号，your_image_name 替换为你加载的镜像的名称。

通过这些步骤，可以将应用程序打包成 Docker 镜像，并从本地加载到 Docker 环境中，以便在容器中运行应用程序。