# 前言
由于国内Docker被屏蔽, 使用Docker变得十分麻烦, 虽然有Docekr镜像站点, 但是总是非常不稳定, 因此我在Github上找到了使用服务器自建Docker镜像站点的方法.
- [Github项目地址](https://github.com/dqzboy/Docker-Proxy?tab=readme-ov-file)



# 需求
> 选择一台国外服务器，并且未被墙。对于域名，无需进行国内备案。你也可以通过一些平台申请免费域名。在一键部署过程中，如果选择安装Caddy，它将自动配置HTTPS。若选择部署Nginx服务，则需要自行申请一个免费的SSL证书，或者通过其他方式来实现SSL加密。

# 部署
- 通过项目脚本部署
```bash
# CentOS && RHEL && Rocky
yum -y install curl
# ubuntu && debian
apt -y install curl

# 国外环境
bash -c "$(curl -fsSL https://raw.githubusercontent.com/dqzboy/Docker-Proxy/main/install/DockerProxy_Install.sh)"

# 国内环境
bash -c "$(curl -fsSL https://cdn.jsdelivr.net/gh/dqzboy/Docker-Proxy/install/DockerProxy_Install.sh)"
```

# 功能
- [x] 一键部署Docker镜像代理服务的功能，支持基于官方Docker Registry的镜像代理.
- [x] 支持多个镜像仓库的代理，包括Docker Hub、GitHub Container Registry(ghcr.io)、Quay Container Registry(quay.io)、Kubernetes Container Registry(k8s.gcr.io)、Microsoft Container(mcr.microsoft.com)、Elastic Stack(docker.elastic.co)
- [x] 自动检查并安装所需的依赖软件，如Docker\Compose、Nginx\Caddy等，并确保系统环境满足运行要求
- [x] 根据你所选择部署的WEB反代服务，自动渲染对应的Nginx或Caddy服务配置
- [x] 自动清理注册表上传目录中的那些不再被任何镜像或清单引用的文件
- [x] 支持自定义配置代理缓存时间(PROXY_TTL)、支持配置IP黑白名单，防止恶意攻击行为
- [x] 提供了服务管理、配置管理、服务卸载、认证授权等功能，方便用户进行日常管理和维护
- [x] 支持一键配置本机Docker代理和容器服务代理(HTTP_PROXY)，仅支持http
- [x] 支持国内服务器一键部署，解决国内环境无法安装Docker\Compose服务难题
- [x] 支持主流Linux发行版操作系统,例如Centos、Ubuntu、Rocky、Debian、Rhel等
- [x] 支持主流ARCH架构下部署，包括linux/amd64、linux/arm64
- [x] 针对本项目开发Docker Registry管理面板，实现镜像搜索、广告展示、文档教程、容器管理、容器监控告警、网络测试等功能

# 文档: [免费公益Docker镜像加速源](https://note.youdao.com/ynoteshare/index.html?id=94b40721172f50a11dca74888bdfa550&type=note&_time=1725177094339)


# 介绍视频
<iframe src="//player.bilibili.com/player.html?aid=1405784818&bvid=BV18r421F7iT&cid=1594996175&p=1&p=1&autoplay=0&high_quality=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" style="width:100%;aspect-ratio:16/10;"> </iframe>

Docker自建docker镜像站

### 如何在 Django 初始化数据库时自动添加数据

在 Django 项目中，有时我们需要在数据库初始化时自动向某些表中插入初始数据。本文将介绍两种方法来实现这一目标：使用 Django 的信号系统和在迁移文件中编写自定义代码。



#### 1. 使用 Django 的信号系统

Django 的信号系统允许你在特定事件发生时执行自定义代码。在这里，我们可以使用 `post_migrate` 信号来在数据库迁移完成后插入初始数据。

**步骤：**

1. **创建信号处理函数**

   在你的 Django 应用中创建一个 `signals.py` 文件（如果没有的话），并添加以下代码：

   ```python
   from django.db.models.signals import post_migrate
   from django.dispatch import receiver
   from .models import Admin

   @receiver(post_migrate)
   def create_default_admin(sender, **kwargs):
       if not Admin.objects.filter(username='admin').exists():
           Admin.objects.create(
               username='admin',
               password='admin',
               phone='12345678900',
               email='admin@123.com'
           )
   ```

   这个函数会在每次迁移完成后检查 `Admin` 表中是否存在用户名为 `'admin'` 的记录，如果不存在则创建一条新记录。

2. **在应用配置中连接信号**

   打开 `apps.py` 文件，并在 `ready` 方法中导入 `signals` 模块：

   ```python
   from django.apps import AppConfig

   class YourAppConfig(AppConfig):
       default_auto_field = 'django.db.models.BigAutoField'
       name = 'your_app_name'

       def ready(self):
           import your_app_name.signals
   ```

   这确保在应用启动时会加载信号处理函数。

3. **运行迁移并测试**

   执行以下命令进行数据库迁移：

   ```bash
   python manage.py migrate
   ```

   这将会自动插入指定的初始数据。

#### 2. 在迁移文件中添加自定义代码

你也可以在 Django 的迁移文件中直接编写代码，以在迁移过程中插入数据。

**步骤：**

1. **创建迁移文件**

   如果还没有迁移文件，可以使用以下命令生成：

   ```bash
   python manage.py makemigrations
   ```

2. **编辑迁移文件**

   在生成的迁移文件中（通常位于 `your_app/migrations/` 目录），添加 `RunPython` 操作以插入数据：

   ```python
   from django.db import migrations

   def create_default_admin(apps, schema_editor):
       Admin = apps.get_model('your_app_name', 'Admin')
       if not Admin.objects.filter(username='admin').exists():
           Admin.objects.create(
               username='admin',
               password='admin',
               phone='12345678900',
               email='admin@123.com'
           )

   class Migration(migrations.Migration):

       dependencies = [
           ('your_app_name', 'previous_migration_name'),  # 替换为实际迁移依赖
       ]

       operations = [
           migrations.RunPython(create_default_admin),
       ]
   ```

   这段代码会在迁移过程中检查 `Admin` 表中是否存在特定记录，如果没有则创建一条新记录。

3. **运行迁移并测试**

   执行迁移命令以应用更改：

   ```bash
   python manage.py migrate
   ```

   这样，在数据库迁移过程中会自动插入指定的数据。

#### 总结

在 Django 项目中，自动插入初始数据可以通过使用信号系统或在迁移文件中编写自定义代码来实现。选择哪种方法取决于你的具体需求和应用场景。希望本文能帮助你在 Django 应用的数据库初始化过程中顺利添加数据。如果有其他问题或需要进一步的帮助，请随时讨论。

如何在 Django 初始化数据库时自动添加数据

# 前言
目前Docker官方的站点、yum源、镜像都无法正常使用, 因此在国内使用Docker会变得十分麻烦, 这里是我总结的目前可以解决的方法

# 安装Docker(CentOS 7)
## 1. 卸载旧版本docker
```bash
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
```



## 2. 安装yum-utils
```bash
sudo yum install -y yum-utils
```

## 3. 使用阿里的镜像repo文件
```bash
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
```

## 4. 安装docker
```bash
sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

## 5. 启动docker
```bash
sudo systemctl start docker
```

## 6. 设置docker开启自启动
```bash
sudo systemctl enable docker
```

# 使用国内Docker镜像仓库站点
```bash
vim /etc/docker/daemon.json
```

```bash
{
  "registry-mirrors": [
    "https://registry.docker-cn.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com",
    "https://hub.uuuadc.top",
    "https://docker.anyhub.us.kg",
    "https://dockerhub.jobcher.com",
    "https://dockerhub.icu",
    "https://docker.ckyl.me",
    "https://docker.awsl9527.cn",
    "https://mirror.baidubce.com"
  ]
}
```

## 具体可以访问此github文章:  [Docker Hub镜像加速器](https://gist.github.com/y0ngb1n/7e8f16af3242c7815e7ca2f0833d3ea6)

国内Docker被屏蔽后安装并拉取Docker镜像

# 问题说明：
- VSCode报 `could not establish trust relationship for the ssl/tls` 
- 重装Linux系统后，VScode无法建立SSH远程连接，检查服务器没有问题，使用SSH工具（putty，cmd）等能正常登陆。



# 解决方法：
**删除用户目录下的VScode配置文件，known_hosts**

- 路径：C:\用户(Users)\(用户名)\.ssh\known_hosts

![image.png](/static/img/059ff072549a92586e78ea55cced08e6.image.webp)

>打开该文件可以看到为连接过的主机存储了一个秘钥，服务器重装后这个秘钥无效了,但VScode可能认为一个特定服务器这个秘钥不会变吧。

重装服务器系统后VSCode SSH登录不上问题

# 界面
![image.png](/static/img/8222c6992c3afb91de749088bb497e6f.image.webp)

# 功能描述
> 用于将小米路由器的sn码转换为ssh连接的root密码



# 代码
```html
<!DOCTYPE html>
<html>
  <body>
    <script>
      /*
       * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
       * Digest Algorithm, as defined in RFC 1321.
       * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
       * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
       * Distributed under the BSD License
       * See http://pajhome.org.uk/crypt/md5 for more info.
       */

      /*
       * Configurable variables. You may need to tweak these to be compatible with
       * the server-side, but the defaults work in most cases.
       */
      var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase        */
      var b64pad =
        ""; /* base-64 pad character. "=" for strict RFC compliance   */
      var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode      */

      /*
       * These are the functions you'll usually want to call
       * They take string arguments and return either hex or base-64 encoded strings
       */
      function hex_md5(s) {
        return binl2hex(core_md5(str2binl(s), s.length * chrsz));
      }
      function b64_md5(s) {
        return binl2b64(core_md5(str2binl(s), s.length * chrsz));
      }
      function str_md5(s) {
        return binl2str(core_md5(str2binl(s), s.length * chrsz));
      }
      function hex_hmac_md5(key, data) {
        return binl2hex(core_hmac_md5(key, data));
      }
      function b64_hmac_md5(key, data) {
        return binl2b64(core_hmac_md5(key, data));
      }
      function str_hmac_md5(key, data) {
        return binl2str(core_hmac_md5(key, data));
      }

      /*
       * Perform a simple self-test to see if the VM is working
       */
      function md5_vm_test() {
        return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
      }

      /*
       * Calculate the MD5 of an array of little-endian words, and a bit length
       */
      function core_md5(x, len) {
        /* append padding */
        x[len >> 5] |= 0x80 << len % 32;
        x[(((len + 64) >>> 9) << 4) + 14] = len;

        var a = 1732584193;
        var b = -271733879;
        var c = -1732584194;
        var d = 271733878;

        for (var i = 0; i < x.length; i += 16) {
          var olda = a;
          var oldb = b;
          var oldc = c;
          var oldd = d;

          a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
          d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
          c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
          b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
          a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
          d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
          c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
          b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
          a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
          d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
          c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
          b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
          a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
          d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
          c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
          b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);

          a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
          d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
          c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
          b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
          a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
          d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
          c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
          b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
          a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
          d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
          c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
          b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
          a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
          d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
          c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
          b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);

          a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
          d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
          c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
          b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
          a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
          d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
          c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
          b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
          a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
          d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
          c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
          b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
          a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
          d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
          c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
          b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);

          a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
          d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
          c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
          b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
          a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
          d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
          c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
          b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
          a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
          d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
          c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
          b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
          a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
          d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
          c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
          b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);

          a = safe_add(a, olda);
          b = safe_add(b, oldb);
          c = safe_add(c, oldc);
          d = safe_add(d, oldd);
        }
        return Array(a, b, c, d);
      }

      /*
       * These functions implement the four basic operations the algorithm uses.
       */
      function md5_cmn(q, a, b, x, s, t) {
        return safe_add(
          bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),
          b
        );
      }
      function md5_ff(a, b, c, d, x, s, t) {
        return md5_cmn((b & c) | (~b & d), a, b, x, s, t);
      }
      function md5_gg(a, b, c, d, x, s, t) {
        return md5_cmn((b & d) | (c & ~d), a, b, x, s, t);
      }
      function md5_hh(a, b, c, d, x, s, t) {
        return md5_cmn(b ^ c ^ d, a, b, x, s, t);
      }
      function md5_ii(a, b, c, d, x, s, t) {
        return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
      }

      /*
       * Calculate the HMAC-MD5, of a key and some data
       */
      function core_hmac_md5(key, data) {
        var bkey = str2binl(key);
        if (bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);

        var ipad = Array(16),
          opad = Array(16);
        for (var i = 0; i < 16; i++) {
          ipad[i] = bkey[i] ^ 0x36363636;
          opad[i] = bkey[i] ^ 0x5c5c5c5c;
        }

        var hash = core_md5(
          ipad.concat(str2binl(data)),
          512 + data.length * chrsz
        );
        return core_md5(opad.concat(hash), 512 + 128);
      }

      /*
       * Add integers, wrapping at 2^32. This uses 16-bit operations internally
       * to work around bugs in some JS interpreters.
       */
      function safe_add(x, y) {
        var lsw = (x & 0xffff) + (y & 0xffff);
        var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
        return (msw << 16) | (lsw & 0xffff);
      }

      /*
       * Bitwise rotate a 32-bit number to the left.
       */
      function bit_rol(num, cnt) {
        return (num << cnt) | (num >>> (32 - cnt));
      }

      /*
       * Convert a string to an array of little-endian words
       * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
       */
      function str2binl(str) {
        var bin = Array();
        var mask = (1 << chrsz) - 1;
        for (var i = 0; i < str.length * chrsz; i += chrsz)
          bin[i >> 5] |= (str.charCodeAt(i / chrsz) & mask) << i % 32;
        return bin;
      }

      /*
       * Convert an array of little-endian words to a string
       */
      function binl2str(bin) {
        var str = "";
        var mask = (1 << chrsz) - 1;
        for (var i = 0; i < bin.length * 32; i += chrsz)
          str += String.fromCharCode((bin[i >> 5] >>> i % 32) & mask);
        return str;
      }

      /*
       * Convert an array of little-endian words to a hex string.
       */
      function binl2hex(binarray) {
        var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
        var str = "";
        for (var i = 0; i < binarray.length * 4; i++) {
          str +=
            hex_tab.charAt((binarray[i >> 2] >> ((i % 4) * 8 + 4)) & 0xf) +
            hex_tab.charAt((binarray[i >> 2] >> ((i % 4) * 8)) & 0xf);
        }
        return str;
      }

      /*
       * Convert an array of little-endian words to a base-64 string
       */
      function binl2b64(binarray) {
        var tab =
          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        var str = "";
        for (var i = 0; i < binarray.length * 4; i += 3) {
          var triplet =
            (((binarray[i >> 2] >> (8 * (i % 4))) & 0xff) << 16) |
            (((binarray[(i + 1) >> 2] >> (8 * ((i + 1) % 4))) & 0xff) << 8) |
            ((binarray[(i + 2) >> 2] >> (8 * ((i + 2) % 4))) & 0xff);
          for (var j = 0; j < 4; j++) {
            if (i * 8 + j * 6 > binarray.length * 32) str += b64pad;
            else str += tab.charAt((triplet >> (6 * (3 - j))) & 0x3f);
          }
        }
        return str;
      }
    </script>
    <h1>小米路由器SSH ROOT密码计算器</h1>

    <p>
      输入SN:<input type="textbox" id="sn" />
      <button onclick="calc()" title="CALC" text="CALC">CALC</button>
    </p>

    <p id="PWD"></p>

    <script>
      let r1d_salt = "A2E371B0-B34B-48A5-8C40-A7133F3B5D88";
      // Salt must be reversed for non-R1D devices
      let others_salt = "d44fb0960aa0-a5e6-4a30-250f-6d2df50a";
      others_salt = others_salt.split("-").reverse().join("-");
      function calc() {
        let sn = document.getElementById("sn").value;
        document.getElementById("PWD").innerHTML = hex_md5(
          sn + (sn.indexOf("/") > 0 ? others_salt : r1d_salt)
        ).substr(0, 8);
      }
    </script>
  </body>
</html>

```