3322软件下载站提供免费的电脑软件下载、APP软件下载、手机应用下载、手机游戏下载、mac苹果软件下载，本站全力打造一个安全、快速、绿色、无病毒的软件和游戏下载平台。

// include

\.vscode\*.*
\src\*.*
*.vue
*.css
*.webp
*.png
*.jpg
*.gif
*.svg
*.txt
*.html
*.js
*.cjs
*.ts
*.tsx
*.json
*.md
*.toml
*.yml
*.yaml
bin\*.*
*.sql
.env*
*.sh
*.php
*.conf
*.php
*.psd
*.rs
*.lock
*.ico
*.woff
*.woff2
*.ttf
*.eot
*.bat

// exclude

\node_modules\
\target\
\.history\
\.git\
*.7z
*.zip
*.rar
.gitignore

vi "/etc/vsftpd/vsftpd.conf"

anonymous_enable=NO

local_enable=YES

write_enable=YES

local_umask=022

dirmessage_enable=YES

xferlog_enable=YES

connect_from_port_20=NO

xferlog_std_format=YES

chroot_local_user=YES

chroot_list_enable=YES

chroot_list_file=/etc/vsftpd/chroot_list

listen=YES

listen_ipv6=NO

pam_service_name=vsftpd
userlist_enable=YES
tcp_wrappers=YES

guest_enable=YES
guest_username=ftpuser
user_config_dir=/etc/vsftpd/vuser

xferlog_enable=YES
xferlog_std_format=YES
xferlog_file=/var/log/xferlog
dual_log_enable=YES
vsftpd_log_file=/var/log/vsftpd.log
allow_writeable_chroot=YES

pasv_enable=yes
pasv_min_port=20121
pasv_max_port=25121
pasv_address=0.0.0.0   # 你的公网 IP
pasv_addr_resolve=YES        # 确保正确解析公网 IP

yum -y install https://nginx.org/packages/rhel/7/x86_64/RPMS/nginx-1.26.1-2.el7.ngx.x86_64.rpm

http://156.225.16.144/user

cargo build --release 默认情况下不会自动并行使用多个 CPU 核心进行编译，但你可以手动启用 多线程编译 来加速构建。

方法 1：使用 JOBS 选项

你可以在编译时使用 -j 选项，指定使用的并行编译线程数。例如：

cargo build --release -j 8

• -j 8 表示使用 8 个核心进行编译。

• 你可以将 8 替换为 $(nproc) 以自动获取 CPU 核心数：

  cargo build --release -j $(nproc)

  这样可以最大化使用 CPU 资源，提高编译速度。

• • *

方法 2：设置 CARGO_BUILD_JOBS 环境变量

如果你不想每次都输入 -j 选项，可以设置环境变量：

export CARGO_BUILD_JOBS=$(nproc)
cargo build --release

或者将其加入 ~/.bashrc / ~/.bash_profile 以使其永久生效：

echo 'export CARGO_BUILD_JOBS=$(nproc)' >> ~/.bashrc
source ~/.bashrc

方法 3：修改 config.toml 配置文件

你还可以在 Cargo 配置文件 中全局设置并行编译：

mkdir -p ~/.cargo
nano ~/.cargo/config.toml

然后添加以下内容：

[build]
jobs = 8  # 或者 $(nproc) 的实际值

保存后，运行 cargo build --release 时会默认使用 8 个核心。

方法 4：使用 sccache 加速编译

如果你的 Rust 项目编译非常缓慢，你还可以使用 sccache 进行缓存加速：

cargo install sccache
export RUSTC_WRAPPER=sccache
cargo build --release -j $(nproc)

sccache 主要用于缓存编译结果，特别适用于 增量编译，加快二次编译速度。

总结

✅ 推荐方式

• 临时并行：cargo build --release -j $(nproc)
• 永久生效：设置 CARGO_BUILD_JOBS 或修改 config.toml
• 加速工具：使用 sccache 进一步优化

最终的cargo.toml

[source.crates-io]
replace-with = 'rsproxy-sparse'

[source.rsproxy]
registry = "https://rsproxy.cn/crates.io-index"

[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"

[registries.rsproxy]
index = "https://rsproxy.cn/crates.io-index"

[net]
git-fetch-with-cli = true

[profile.dev]
opt-level = 0               # 优化等级最低，编译速度最快（默认值）
debug = true                # 保留调试符号，方便调试和断点追踪
codegen-units = 16          # 生成多个并行代码单元，加快多核编译速度
incremental = true          # 启用增量编译，修改部分代码时加速后续编译
overflow-checks = false     # 关闭整数溢出检查（调试时略快，需小心）

[profile.release]
opt-level = "z"             # 优化最小二进制体积（比 "s" 更激进）
lto = false                 # 关闭 LTO（Link Time Optimization），加快构建但牺牲些许体积
codegen-units = 8           # 控制并行生成单元，8 通常能平衡速度和优化
panic = "abort"             # 遇到 panic 时直接终止，无回溯，减小代码体积
strip = true                # 编译后移除符号表和调试信息，减小最终文件体积

[alias]
b = "build --release"
r = "run --release"

[build]
jobs = 16

这样，你的 cargo build --release 就可以 最大限度利用多核 CPU 进行编译了 🚀

cpu_test.sh

#!/bin/bash

# 获取 CPU 核心数
CPU_COUNT=$(nproc)

# 定义一个数组存储进程 ID
declare -a PIDS

# 计算密集型任务（无限循环计算）
cpu_stress() {
    while :; do :; done
}

echo "开始逐步激活 CPU 核心..."

# 逐个核心启动计算任务
for ((i=1; i<=CPU_COUNT; i++)); do
    cpu_stress &  # 后台运行计算任务
    PIDS+=($!)   # 记录进程 ID
    echo "已激活 ${i} 个核心..."
    sleep 1  # 每秒增加一个核心
done

echo "CPU 已全部占满，保持 5 秒..."

# 维持 CPU 满载 5 秒
sleep 5

echo "开始逐步释放 CPU 核心..."

# 逐个终止计算任务
for ((i=CPU_COUNT-1; i>=0; i--)); do
    kill ${PIDS[i]}
    unset PIDS[i]
    echo "已释放 ${CPU_COUNT-i} 个核心..."
    sleep 1  # 每秒释放一个核心
done

echo "所有 CPU 核心已释放，脚本结束。"

Powerful note-taking app with nested documents, full-text search, rich-text editor, code snippet editor and more - lukasbach/yana

use sea_orm_migration::prelude::*;
use std::fs;
use std::process::Command;

#[derive(DeriveMigrationName)]
pub struct Migration;

// SQL 文件中的占位符，需要替换成 SCHEMA
const SQL_FILE_SCHEMA: &str = "dev_001";

// 常量：数据库 schema 名称
const SCHEMA: &str = "dev_002";

// 要读取的 SQL 文件
const SQL_FILE_PATH: &str = "C:\\PATH\\Ccreate_table.sql";

// 直接使用 `DATABASE_URL` 常量
const DATABASE_URL: &str = "postgres://postgres:123456@localhost:5432/purchasing";

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        // 创建 schema 的 SQL 语句（不变）
        let create_schema_sql = format!(
            r#"
            DO $$ 
            BEGIN 
                IF NOT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = '{SCHEMA}') 
                THEN CREATE SCHEMA {SCHEMA}; 
                END IF; 
            END $$;
            "#
        );

        // 读取 SQL 文件（可变）
        let create_table_sql = match fs::read_to_string(SQL_FILE_PATH) {
            Ok(content) => content.replace(SQL_FILE_SCHEMA, SCHEMA), // 替换 schema 占位符
            Err(err) => {
                println!("❌ 读取 SQL 文件 `{}` 失败: {}", SQL_FILE_PATH, err);
                return Err(DbErr::Custom(format!("无法读取 SQL 文件: {}", err)));
            }
        };

        // 执行创建 schema 语句（如果 schema 不存在）
        manager.get_connection().execute_unprepared(&create_schema_sql).await?;
        // 执行创建 users 表的 SQL（从文件读取）
        manager.get_connection().execute_unprepared(&create_table_sql).await?;

        println!("✅ 成功执行 SQL 文件 `{}`，创建 schema `{}`", SQL_FILE_PATH, SCHEMA);

        // 运行 sea-orm-cli 生成实体
        let cmd_args = [
            "generate",
            "entity",
            "--output-dir",
            "./src/entity",
            "--database-schema",
            SCHEMA,
            "--database-url",
            DATABASE_URL,
        ];

        let output = Command::new("sea-orm-cli")
            .args(&cmd_args)
            .env("DATABASE_URL", DATABASE_URL) // 手动传递 DATABASE_URL
            .output();

        match output {
            Ok(output) if output.status.success() => {
                println!("✅ SeaORM 实体已成功更新！");
                println!("📝 SeaORM 输出 (stdout):\n{}", String::from_utf8_lossy(&output.stdout));
            }
            Ok(output) => {
                println!("⚠️ SeaORM 实体更新失败: {:?}", String::from_utf8_lossy(&output.stderr));
            }
            Err(err) => {
                println!("❌ 无法运行 sea-orm-cli: {}", err);
            }
        }

        // 打印命令，方便调试
        println!("🚀 手动执行命令更新实体: \n\nsea-orm-cli {}\n\n", cmd_args.join(" "));

        Ok(())
    }

    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        // 删除 schema 及所有表
        let drop_schema_sql = format!(
            r#"
            DROP SCHEMA IF EXISTS {SCHEMA} CASCADE;
            "#
        );

        // 执行删除 schema 及其所有表的 SQL
        manager.get_connection().execute_unprepared(&drop_schema_sql).await?;

        println!("✅ 成功删除 schema `{}` 及所有表", SCHEMA);
        Ok(())
    }
}

✅ 可以用 Navicat 直接设计表结构

✅ 导出 SQL 结构后，直接放到 create_table.sql 里

✅ migrate up 自动创建 SCHEMA 并执行 SQL，不需要手动改 Rust 代码

✅ 如果要换 schema，只需要改 SCHEMA 变量，甚至可以让它动态读取环境变量

在 Alpine Linux 上安装和配置 NFS 服务器可以按照以下步骤进行：

1. 安装 NFS 服务器

使用 apk 安装 nfs-utils：

apk add nfs-utils

如果你使用的是 OpenRC（Alpine 默认的 init system），还需要安装 nfs-utils-openrc：

apk add nfs-utils-openrc

2. 配置 NFS 共享目录

编辑 /etc/exports 文件，添加要共享的目录。例如：

mkdir -p /mnt/nfs_share
chmod 777 /mnt/nfs_share
echo "/mnt/nfs_share *(rw,sync,no_subtree_check,no_root_squash)" >> /etc/exports

参数说明：

• *：允许所有客户端访问（你可以替换为特定 IP，比如 192.168.1.0/24）。
• rw：读写权限。
• sync：数据同步写入磁盘，提高稳定性。
• no_subtree_check：避免子目录检查，提高访问性能。
• no_root_squash：允许 NFS 客户端以 root 用户访问（通常默认会将 root 映射到 nobody）。

3. 启动 NFS 服务器

运行以下命令启动 NFS 相关服务：

rc-service nfs start
rc-service rpcbind start

4. 设置开机自启

rc-update add nfs default
rc-update add rpcbind default

5. 重新导出 NFS 目录

如果你修改了 /etc/exports，需要运行以下命令使更改生效：

exportfs -a

6. 在客户端挂载 NFS 共享

假设服务器 IP 是 192.168.1.100，在 NFS 客户端（另一台 Linux 机器）上运行：

apk add nfs-utils
mkdir -p /mnt/nfs_client
mount -t nfs 192.168.1.100:/mnt/nfs_share /mnt/nfs_client

如果要 永久挂载，可以在客户端的 /etc/fstab 添加：

192.168.1.100:/mnt/nfs_share  /mnt/nfs_client  nfs  defaults  0  0

7. 检查 NFS 状态

查看 NFS 服务器导出的共享目录：

exportfs -v

查看 NFS 服务器是否在监听：

rpcinfo -p

8. 防火墙（可选）

如果 Alpine 使用 iptables 或 firewalld，确保放行 NFS 相关端口：

iptables -A INPUT -p tcp --dport 2049 -j ACCEPT
iptables -A INPUT -p udp --dport 2049 -j ACCEPT

这样你就成功在 Alpine Linux 上安装并配置了 NFS 服务器！🎉

用户名和密码认证

在 Alpine Linux 上设置 NFS 服务器 并启用 用户名和密码认证（Kerberos 认证） 需要使用 NFSv4 + Kerberos（sec=krb5），因为 NFS 本身不支持基于用户名/密码的身份验证。默认情况下，NFS 主要依赖客户端和服务器的 UID/GID 进行身份匹配。

如果你只是想实现 基本的身份控制，可以使用 root_squash 或 map_static 方式。但如果你想要真正的 用户名和密码认证，你需要结合 Kerberos 进行身份验证。

方案 1：基于 Kerberos 认证的 NFS（推荐）

1. 安装必要的组件

apk add nfs-utils rpcbind krb5-server krb5

2. 配置 Kerberos

编辑 /etc/krb5.conf

[libdefaults]
 default_realm = EXAMPLE.COM
 dns_lookup_realm = false
 dns_lookup_kdc = false

[realms]
 EXAMPLE.COM = {
  kdc = your-kerberos-server
  admin_server = your-kerberos-server
 }

[domain_realm]
 .example.com = EXAMPLE.COM
 example.com = EXAMPLE.COM

注意：

• EXAMPLE.COM 请改为你的域名。
• your-kerberos-server 替换为你的 Kerberos 服务器 IP 或主机名。

3. 生成密钥表

在 Kerberos KDC 服务器 上创建一个 nfs/服务器名 的主机密钥：

kadmin.local
addprinc -randkey nfs/server.example.com
ktadd -k /etc/krb5.keytab nfs/server.example.com

然后，将 /etc/krb5.keytab 复制到 NFS 服务器 和 客户端。

4. 配置 NFS 服务器

编辑 /etc/exports：

/mnt/nfs_share 192.168.1.0/24(rw,sec=krb5p,sync,no_subtree_check)

sec=krb5p 表示 使用 Kerberos 进行身份验证，你也可以改为：

• sec=krb5 仅验证身份
• sec=krb5i 验证身份+数据完整性
• sec=krb5p 验证身份+数据完整性+加密

然后重启服务：

rc-service nfs restart
rc-service rpcbind restart
exportfs -ra

5. 在客户端挂载 NFS

在 客户端 确保已经安装了 nfs-utils 和 krb5，然后运行：

mkdir -p /mnt/nfs_client
mount -t nfs4 -o sec=krb5 server.example.com:/mnt/nfs_share /mnt/nfs_client

方案 2：使用 map_static 进行用户映射（非用户名/密码）

如果你只是想让 特定的用户名匹配到 NFS 服务器上的某个 UID/GID，可以使用 map_static。

1. 创建映射文件

在 NFS 服务器上，创建 /etc/idmapd.conf 并添加：

[General]
Domain = example.com

[Mapping]
Nobody-User = nfsnobody
Nobody-Group = nfsnobody

然后，创建 /etc/nfsidmap.conf：

echo "nfsuser:1001:1001" > /etc/nfsidmap.conf

这里 nfsuser 是客户端的用户名，它将被映射到服务器上的 UID/GID 1001。

重启 idmapd：

rc-service rpcidmapd restart

然后，在客户端：

mount -t nfs4 -o sec=sys server.example.com:/mnt/nfs_share /mnt/nfs_client

总结

如果你想在 Alpine Linux 上真正使用用户名和密码进行 NFS 认证，推荐使用 Kerberos！

在 Windows 10 上挂载 NFS 共享，可以按照以下步骤进行：

1. 启用 NFS 客户端

默认情况下，Windows 10 需要手动安装 NFS 客户端：

方法 1：使用 "启用或关闭 Windows 功能"

1. 打开"控制面板" → 选择 "程序和功能"。
2. 点击左侧 "启用或关闭 Windows 功能"。
3. 在弹出的窗口中，找到 "NFS 客户端"（Client for NFS）。
4. 勾选它，然后点击 "确定"，等待安装完成。
5. 重启计算机。

方法 2：使用 PowerShell 安装

你也可以用 PowerShell 快速安装：

Enable-WindowsOptionalFeature -Online -FeatureName ServicesForNFS-ClientOnly -NoRestart

安装完成后，建议重启 Windows。

2. 挂载 NFS 共享

方法 1：使用 "net use" 命令

打开 命令提示符 (cmd)，运行：

net use X: \\192.168.1.100\mnt\nfs_share /persistent:yes

• X: 是你希望映射的本地磁盘盘符，可以换成 Z: 或其他未使用的盘符。
• 192.168.1.100 是 NFS 服务器的 IP 地址，需要替换成你的实际 NFS 服务器 IP。
• /persistent:yes 让 NFS 共享在重启后仍然保持挂载状态。

方法 2：使用 "mount" 命令

如果 net use 方式不工作，可以尝试：

mount -o anon \\192.168.1.100\mnt\nfs_share X:

如果 NFS 服务器要求身份认证，你可以使用：

mount -o username=your_user,password=your_password \\192.168.1.100\mnt\nfs_share X:

方法 3：通过 "文件资源管理器"

1. 打开文件资源管理器 → 右键 "此电脑" → "映射网络驱动器"。

2. 选择一个盘符，例如 X:。

3. 在 文件夹 位置输入：

   \\192.168.1.100\mnt\nfs_share

4. 取消勾选 "使用不同的凭据连接"（NFS 默认使用匿名访问）。

5. 点击 "完成"，等待挂载成功。

3. 验证挂载

挂载成功后，你可以：

• 在 文件资源管理器 中查看 X: 盘是否正常访问。

• 运行 net use 查看挂载状态：

  net use

• 运行 mount 命令查看 NFS 挂载：

  mount

• • *

4. 取消 NFS 挂载

如果不需要 NFS 共享了，可以卸载：

net use X: /delete

或者：

umount X:

5. 可能的故障排除

问题 1：找不到 NFS 共享

• 确保 Windows 10 的 NFS 客户端 已安装并启用。

• 确保 NFS 服务器的 IP 地址正确，可以 ping 测试：

  ping 192.168.1.100

• 在服务器端运行：

  exportfs -v

  确保 NFS 共享已正确导出。

问题 2：Windows 访问 NFS 目录时报 "权限不足"

• 在 NFS 服务器上，尝试设置 no_root_squash 以允许 Windows 访问：

  echo "/mnt/nfs_share *(rw,sync,no_subtree_check,no_root_squash)" >> /etc/exports

  然后重新加载：

  exportfs -ra

• 在 Windows 端，尝试使用 管理员权限 运行 cmd 进行挂载。

• • *

这样，你就能在 Windows 10 上成功挂载 NFS 共享了！🚀

官网参考

https://wiki.alpinelinux.org/wiki/Setting_up_an_NFS_server

Alpine Linux 官网提供的方法更简便，并且更符合 Alpine 的设计哲学。相比之前介绍的步骤，它减少了一些手动配置，依赖 OpenRC 进行管理，适用于 Alpine 的 轻量级环境。

对比分析

✅ Alpine 官方方法的优势：

1. 减少手动操作，直接使用 rc-update 管理 NFS 服务。
2. 更符合 Alpine Linux 的 OpenRC 体系，避免使用 systemctl 等非 Alpine 工具。
3. 不需要额外的 rpcbind 配置（NFSv4 默认不需要 rpcbind）。

按照官网方法安装 NFS 服务器

1. 安装 nfs-utils

apk add nfs-utils

2. 配置 NFS 共享

编辑 /etc/exports：

/data 10.10.10.0/24(rw,nohide,no_subtree_check,no_root_squash)

3. 重新加载导出设置

exportfs -afv

4. 启动 NFS 服务

rc-service nfs start

5. 设置开机自启

rc-update add nfs

按照官网方法安装 NFS 客户端

1. 确保安装 nfs-utils

apk add nfs-utils

2. 在 /etc/fstab 中添加自动挂载

10.10.10.1:/data /mnt/nfs_share nfs4 rw,_netdev 0 0

3. 启用自动挂载

rc-update add nfsmount
rc-service nfsmount start

官方方法设置 Kerberos 认证（可选）

如果你需要 Kerberos 认证，官网方法也更简洁：

1. 在 NFS 服务器上

apk add krb5-server
kadmin.local
addprinc -randkey nfs/nfs1.example.com@EXAMPLE.COM
ktadd -k /etc/krb5.keytab nfs/nfs1.example.com

编辑 /etc/exports：

/data 10.10.10.0/24(rw,nohide,no_subtree_check,sec=krb5p,no_root_squash)

重新加载：

exportfs -afv

2. 在 NFS 客户端上

apk add krb5
rc-update add rpc.gssd
rc-service rpc.gssd start

然后挂载：

mount -t nfs4 -o sec=krb5 10.10.10.1:/data /mnt/nfs_client

结论

✅ Alpine 官网的方法 更简便、更轻量级，而且利用了 Alpine OpenRC 进行管理，建议直接按照官网方法操作！🚀

使用sea-orm-cli管理数据库的一般操作：

安装sea-orm-cli

cargo install sea-orm-cli

rustup component add rustfmt

在项目文件夹下创建.env数据库连接配置文件：

DATABASE_URL=postgres://postgres:123456@localhost:5432/purchasing?options=-c%20search_path%3Ddev_001

使用 sea-orm-cli migrate init 进行初始化操作。

然后记得修改./migration/Cargo.toml
改成这样：

...
[dependencies]
async-std = { version = "1", features = ["attributes", "tokio1"] }

[dependencies.sea-orm-migration]
version = "1.1.0"
features = [
  # Enable at least one `ASYNC_RUNTIME` and `DATABASE_DRIVER` feature if you want to run migration via CLI.
  # View the list of supported features at https://www.sea-ql.org/SeaORM/docs/install-and-config/database-and-async-runtime.
  # e.g.
   "runtime-tokio-rustls",  # `ASYNC_RUNTIME` feature
   "sqlx-postgres",         # `DATABASE_DRIVER` feature
]

也就是去掉下面的"#"号注释。

   # "runtime-tokio-rustls",  # `ASYNC_RUNTIME` feature
   # "sqlx-postgres",         # `DATABASE_DRIVER` feature

生成或更新实体文件 →

使用 sea-orm-cli generate entity 生成或更新实体文件

sea-orm-cli generate entity --output-dir ./src/entity --database-schema dev_001 --database-url "postgres://postgres:123456@localhost:5432/purchasing"

创建新的数据库或修改数据库结构迁移 →

使用 sea-orm-cli migrate generate 生成当前状态的迁移文件

sea-orm-cli migrate generate status_name

这样会在./migration/src文件夹下生成指定的status_name.rs

然后设计你的数据库改动，以后改动一次就执行一次并设计一次。

应用数据库变更 →

使用 sea-orm-cli migrate up 或 sea-orm-cli migrate down

如果需要重新进行迁移重置 →

使用 sea-orm-cli migrate init 进行重置操作。
然后记得修改./migration/Cargo.toml
改成这样：

...
[dependencies]
async-std = { version = "1", features = ["attributes", "tokio1"] }

[dependencies.sea-orm-migration]
version = "1.1.0"
features = [
  # Enable at least one `ASYNC_RUNTIME` and `DATABASE_DRIVER` feature if you want to run migration via CLI.
  # View the list of supported features at https://www.sea-ql.org/SeaORM/docs/install-and-config/database-and-async-runtime.
  # e.g.
   "runtime-tokio-rustls",  # `ASYNC_RUNTIME` feature
   "sqlx-postgres",         # `DATABASE_DRIVER` feature
]

也就是去掉下面的"#"号注释。

   # "runtime-tokio-rustls",  # `ASYNC_RUNTIME` feature
   # "sqlx-postgres",         # `DATABASE_DRIVER` feature

通过实体文件进行数据库操作 →

在代码中通过实体文件执行 CRUD 操作

在线AES加密，AES解密，可以输入密钥后进行加密和解密，支持可逆加密解密。

硅基流动致力于打造规模化、标准化、高效能 AI Infra 平台，提供高效能、低成本的多品类 AI 模型服务，助力开发者和企业聚焦产品创新。

CentOS7

hostname mynewhostname

vi /etc/hostname

vi /etc/sysconfig/network
→HOSTNAME=mynewhostname

sudo systemctl restart systemd-hostnamed

Ubuntu

hostname mynewhostname

vi /etc/hostname

vi /etc/hosts
→127.0.1.1    mynewhostname

sudo systemctl restart systemd-logind.service

Alpine

hostname mynewhostname

vi /etc/hostname

vi /etc/hosts
→127.0.1.1    mynewhostname

sudo service hostname restart

验证主机名修改

hostname

yum remove docker  docker-common docker-selinux docker-engine

yum install -y yum-utils device-mapper-persistent-data lvm2

yum-config-manager --add-repo http://download.docker.com/linux/centos/docker-ce.repo
（中央仓库）

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
（阿里仓库）

yum list docker-ce --showduplicates | sort -r

yum -y install docker-ce-18.06.3.ce

systemctl start docker
systemctl enable docker

docker rm $(docker ps -aq)

docker pull alpine

mkdir -p /data1/docker_data/web_service_alpine

docker volume create --driver local -o type=none -o device=/data1/docker_data/web_service_alpine -o o=bind web_service_alpine

docker run -it --name web_apline -v web_service_alpine:/service --memory="256m" --cpus="1" -p 22001:22 alpine

cat <<EOF > /etc/apk/repositories
#/media/cdrom/apks
https://mirrors.nju.edu.cn/alpine/latest-stable/main/
https://mirrors.tuna.tsinghua.edu.cn/alpine/latest-stable/main/
https://mirrors.nju.edu.cn/alpine/latest-stable/community/
https://mirrors.tuna.tsinghua.edu.cn/alpine/latest-stable/community/

https://mirrors.nju.edu.cn/alpine/v3.21/main/
https://mirrors.tuna.tsinghua.edu.cn/alpine/v3.21/main/
https://mirrors.nju.edu.cn/alpine/v3.21/community/
https://mirrors.tuna.tsinghua.edu.cn/alpine/v3.21/community/

https://mirrors.nju.edu.cn/alpine/edge/main/
https://mirrors.tuna.tsinghua.edu.cn/alpine/edge/main/
https://mirrors.nju.edu.cn/alpine/edge/community/
https://mirrors.tuna.tsinghua.edu.cn/alpine/edge/community/

https://mirrors.nju.edu.cn/alpine/edge/testing/
https://mirrors.tuna.tsinghua.edu.cn/alpine/edge/testing/
EOF

apk update

apk add shadow openssh openssl openrc

sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config
cat /etc/ssh/sshd_config | grep "PermitRootLogin"
cat /etc/ssh/sshd_config | grep "PasswordAuthentication"

ssh-keygen -A

passwd

rc-update add sshd
rc-service sshd start

/usr/sbin/sshd -D &

ssh-keygen -f "/root/.ssh/known_hosts" -R "[127.0.0.1]:22001"

ssh root@127.0.0.1 -p 22001

docker volume create --driver local -o type=none -o device=/docker_data/web_service_alpine -o o=bind web_service_alpine
docker run -it --name web_apline -v web_service_alpine:/service --memory="512m" --cpus="1" -p 22001:22 -p 10080:80 -p 10443:443 v_alpine

docker run -it --name web_apline -v web_service_alpine:/service --memory="256m" --cpus="1" -p 22001:22 v_alpine

/docker_data/dockerfile# cat Dockerfile
FROM v_alpine:latest

# 配置 SSH 服务
RUN ssh-keygen -A

# 设置 root 密码
RUN echo 'root:zjf6617' | chpasswd

# 启动 sshd 服务
CMD ["/usr/sbin/sshd", "-D", "&"]
root@C20250126506523:/docker_data/dockerfile# docker build -t ssh_v_alpine .

docker run -it --name web_apline -v web_service_alpine:/service --memory="256m" --cpus="1" -p 22001:22 ssh_v_alpine

docker build -f ./docker_file_for_alpine -t ssh_v_alpine:latest .

docker build -f ./docker_file_for_alpine -t nginx_php_redis:latest .

docker run -it --name web_apline -v web_service_alpine:/service --memory="512m" --cpus="1" -p 22001:22 -p 10080:80 -p 10443:443 nginx_php_redis
docker run -it --name web_apline --memory="512m" --cpus="1" -p 22001:22 -p 10080:80 -p 10443:443 nginx_php_redis

docker run -it --name web_apline_lasting -v web_service_alpine:/service --memory="512m" --cpus="1" -p 22001:22 -p 25080:80 -p 25443:443 nginx_php_redis

docker run -it --name web_apline_template --memory="512m" --cpus="1" -p 22001:22 -p 25080:80 -p 25443:443 nginx_php_redis

docker run -it --name apline_template --hostname XBY-CD-VAPLINE-DOCKER --add-host XBY-CD:127.0.0.1 --memory="512m" --cpus="1" --privileged v_alpine

vi /etc/apk/repositories

#/media/cdrom/apks
https://mirrors.nju.edu.cn/alpine/latest-stable/main/
https://mirrors.tuna.tsinghua.edu.cn/alpine/latest-stable/main/
https://mirrors.nju.edu.cn/alpine/latest-stable/community/
https://mirrors.tuna.tsinghua.edu.cn/alpine/latest-stable/community/

https://mirrors.nju.edu.cn/alpine/v3.21/main/
https://mirrors.tuna.tsinghua.edu.cn/alpine/v3.21/main/
https://mirrors.nju.edu.cn/alpine/v3.21/community/
https://mirrors.tuna.tsinghua.edu.cn/alpine/v3.21/community/

https://mirrors.nju.edu.cn/alpine/edge/main/
https://mirrors.tuna.tsinghua.edu.cn/alpine/edge/main/
https://mirrors.nju.edu.cn/alpine/edge/community/
https://mirrors.tuna.tsinghua.edu.cn/alpine/edge/community/

https://mirrors.nju.edu.cn/alpine/edge/testing/
https://mirrors.tuna.tsinghua.edu.cn/alpine/edge/testing/

taskkill /fi "username eq Administrator"

GitCode是面向全球开发者的开源社区,包括原创博客,开源代码托管,代码协作,项目管理等。与开发者社区互动,提升您的研发效率和质量。