Eucalyptus

anzhiyu主题新添文章卡片样式

Mon, 13 Apr 2026 06:19:46 GMT

前言

这份教程，记录了我为 AnZhiYu 主题添加横向卡片样式的全部过程。代码不多，但每一处都仔细调整过：斜切的视觉平衡、移动端的适配、分页后的稳定性……甚至强迫自己解决了偶数页布局错乱的 bug。

代码不是束缚，是自由的工具。愿你的博客，也能长出属于自己的姿态。

正文

文件路径分布

blog/                          # Hexo 博客根目录
├── themes/
│   └── anzhiyu/                    # AnZhiYu 主题目录
│       ├── layout/                 # 布局模板目录
│       │   ├── includes/           # 包含组件目录
│       │   │   └── mixins/         # mixins 组件目录
│       │   │       └── post-ui-horizontal.pug    # ← 横向卡片 Pug 模板
│       │   └── index.pug           # ← 首页布局文件（调用横向卡片）
│       └── ...                     # 其他主题文件
├── source/                         # 源文件目录（会被复制到 public）
│   └── cdn/                        # CDN 资源目录
│       └── css/
│           └── horizontal-card.css # ← 横向卡片样式文件（你提供的 CSS）
└── ...                             # 其他博客文件

新建post-ui-horizontal.pug

mixin postUIHorizontal()
  - let maxDate = 0
  each item in site.posts.data
    if item.date > maxDate
      - maxDate = item.date

  .horizontal-post-list
    each article, index in page.posts.data
      - let link = article.link || article.path
      - let title = article.title || _p('no_title')
      - let post_cover = article.cover
      - let desc = article.description || article.excerpt || ''
      - let category = article.categories.data[0]
      - let dateStr = date(article.date, 'MM-DD')
      - let wc = wordcount(article.content)
      - const new_post = is_current('/') && (maxDate === article.date)
      // 判断左右位置：偶数左边，奇数右边
      - let isLeft = index % 2 === 0
      
      article.recent-post-item.horizontal-card(class=isLeft ? 'image-right' : 'image-left' onclick=`pjax.loadUrl('${url_for(link)}')`)
        // 图片在左（奇数卡片）
        if !isLeft && post_cover && theme.cover.index_enable
          .post-cover
            a(href=url_for(link) title=title)
              img.post_bg(src=url_for(post_cover) onerror=`this.onerror=null;this.src='`+ url_for(theme.error_img.post_page) + `'` alt=title loading="lazy")
        
        // 无图片占位（奇数卡片）
        if !isLeft && !(post_cover && theme.cover.index_enable)
          .post-cover.no-image
            a(href=url_for(link) title=title)
              .cover-placeholder
        
        // 内容区
        .post-content
          .post-content-top
            .post-tips
              if (is_home() && (article.top || article.sticky > 0))
                span.article-meta.sticky-warp
                  i.anzhiyufont.anzhiyu-icon-thumbtack.sticky
                  span.sticky= _p('sticky')
            
            a.post-title(href=url_for(link) title=title)= title

          .post-meta-wrap
            if (theme.post_meta.page.date_type)
              span.post-meta-date
                if (theme.post_meta.page.date_type === 'both')
                  i.anzhiyufont.anzhiyu-icon-calendar-alt(style=`${theme.post_meta.page.date_format==="simple" ? "display:none":""}`)
                  span.article-meta-label=_p('post.created')
                  time.post-meta-date-created(datetime=date_xml(article.date) title=_p('post.created') + ' ' + full_date(article.date) time=full_date(article.date))=date(article.date, config.date_format)
                  span.article-meta-separator
                  i.anzhiyufont.anzhiyu-icon-history(style=`font-size: 15px; ${theme.post_meta.page.date_format==="simple" ? "display:none":""}`)
                  span.article-meta-label=_p('post.updated')
                  time.post-meta-date-updated(datetime=date_xml(article.updated) title=_p('post.updated') + ' ' + full_date(article.updated) time=full_date(article.updated))=date(article.updated, config.date_format)
                else
                  - let data_type_updated = theme.post_meta.page.date_type === 'updated'
                  - let date_type = data_type_updated ? 'updated' : 'date'
                  - let date_type_other = data_type_updated ? 'date' : 'updated'
                  - let date_icon = data_type_updated ? 'anzhiyu-icon-history' :'anzhiyu-icon-calendar-days'
                  - let date_title = data_type_updated ? _p('post.updated') : _p('post.created')
                  - let date_title_other = data_type_updated ? _p('post.created') : _p('post.updated')
                  i.anzhiyufont(class=date_icon style=`font-size: 15px; ${theme.post_meta.page.date_format==="simple" ? "display:none":""}`)
                  span.article-meta-label=date_title
                  time(datetime=date_xml(article[date_type]) title=date_title + ' ' + full_date(article[date_type])  time=full_date(article[date_type]))=date(article[date_type], config.date_format)
                  time(datetime=date_xml(article[date_type_other]), class="time_hidden", title=date_title_other + ' ' + full_date(article[date_type_other]) time=full_date(article[date_type_other]))=date(article[date_type_other], config.date_format)
            
            if (theme.post_meta.page.tags && article.tags.data.length > 0)
              span.article-meta.tags
                each item, index in article.tags.data
                  a(href=url_for(item.path) event.cancelbubble onclick="window.event.cancelBubble=true;").article-meta__tags
                    span 
                      i.anzhiyufont.anzhiyu-icon-hashtag
                      =item.name
            
            mixin countBlockHorizontal
              - needLoadCountJs = true
              span.article-meta
                span.article-meta-separator
                i.eucalyptus.icon-comments
                if block
                  block
                span.article-meta-label= ' ' + _p('card_post_count')
            
            if theme.comments.card_post_count
              case theme.comments.use[0]
                when 'Valine'
                  +countBlockHorizontal
                    a(href=url_for(link) + '#post-comment')
                      span.valine-comment-count(data-xid=url_for(link))
                        i.anzhiyufont.anzhiyu-icon-spinner.anzhiyu-spin
                when 'Waline'
                  +countBlockHorizontal
                    a(href=url_for(link) + '#post-comment')
                      span.waline-comment-count(id=url_for(link))
                        i.anzhiyufont.anzhiyu-icon-spinner.anzhiyu-spin
                when 'Twikoo'
                  +countBlockHorizontal
                    a.twikoo-count(href=url_for(link) + '#post-comment' tabindex="-1")
                      i.anzhiyufont.anzhiyu-icon-spinner.anzhiyu-spin
                when 'Artalk'
                  +countBlockHorizontal
                    a(href=url_for(link) + '#post-comment')
                      span.artalk-count(data-page-key=url_for(link))
                        i.anzhiyufont.anzhiyu-icon-spinner.anzhiyu-spin

          case theme.index_post_content.method
            when false
              - break
            when 1
              .post-desc!= article.description
            when 2
              if article.description
                .post-desc!= article.description
              else
                - const content = strip_html(article.content)
                - let expert = content.substring(0, theme.index_post_content.length) 
                - content.length > theme.index_post_content.length ? expert += ' ...' : ''
                .post-desc!= expert
            default
              - const content = strip_html(article.content)
              - let expert = content.substring(0, theme.index_post_content.length) 
              - content.length > theme.index_post_content.length ? expert += ' ...' : ''
              .post-desc!= expert

        // 图片在右（偶数卡片）
        if isLeft && post_cover && theme.cover.index_enable
          .post-cover
            a(href=url_for(link) title=title)
              img.post_bg(src=url_for(post_cover) onerror=`this.onerror=null;this.src='`+ url_for(theme.error_img.post_page) + `'` alt=title loading="lazy")
        
        // 无图片占位（偶数卡片）
        if isLeft && !(post_cover && theme.cover.index_enable)
          .post-cover.no-image
            a(href=url_for(link) title=title)
              .cover-placeholder

      if theme.ad && theme.ad.index
        if (index + 1) % 3 == 0
          .horizontal-card.ads-wrap!=theme.ad.index

修改index.pug

extends includes/layout.pug

block content
  include ./includes/mixins/post-ui.pug
  
  // 关键：include 必须在顶层，不能放在 if 里面
  include ./includes/mixins/post-ui-horizontal.pug
  
  #recent-posts.recent-posts
    include includes/categoryGroup.pug
    
    if theme.home_card_style === 'horizontal'
      +postUIHorizontal()
    else
      +postUI
    
    include includes/pagination.pug

新建horizontal-card.css

/* ========== 变量定义 ========== */
:root {
    --card-bg: #1a1a2e;
    --card-bg-alt: #16213e;
    --theme-color: #e94560;
    --skew-width: 60px;
}

/* ========== 基础卡片样式 ========== */
.horizontal-card {
    display: flex;
    flex-direction: row;
    width: 100%;
    height: 260px;
    border-radius: 16px;
    overflow: hidden;
    background: var(--card-bg);
    box-shadow: 0 8px 32px rgba(0,0,0,0.3);
    transition: all 0.4s ease;
    cursor: pointer;
    position: relative;
    margin-bottom: 32px;
}

.horizontal-card:hover {
    transform: translateY(-6px);
    box-shadow: 0 16px 48px rgba(233, 69, 96, 0.15);
}

/* ========== 内容区域基础 ========== */
.horizontal-card .post-content {
    width: calc(58% - 0px);
    flex: 0 0 calc(58% - 0px);
    max-width: calc(58% - 0px);
    padding: 32px 40px;
    display: flex;
    flex-direction: column;
    justify-content: space-between;
    position: relative;
    z-index: 2;
    min-width: 0;
    overflow: hidden;
    box-sizing: border-box;
}

.horizontal-card .post-title {
    font-size: 1.6rem;
    font-weight: 700;
    line-height: 1.3;
    display: -webkit-box;
    -webkit-line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
    margin-bottom: 4px;
    word-break: break-word;
    overflow-wrap: break-word;
}

.horizontal-card .post-desc {
    font-size: 1rem;
    line-height: 1.8;
    display: -webkit-box;
    -webkit-line-clamp: 2;
    -webkit-box-orient: vertical;
    overflow: hidden;
    margin-top: 12px;
    word-break: break-word;
    overflow-wrap: break-word;
}

/* ========== 图片区域基础 ========== */
.horizontal-card .post-cover {
    width: calc(42% - 0px);
    flex: 0 0 calc(42% - 0px);
    max-width: calc(42% - 0px);
    min-width: 320px;
    height: 100%;
    position: relative;
    overflow: hidden;
    box-sizing: border-box;
}

.horizontal-card .post-cover img {
    width: 100%;
    height: 100%;
    object-fit: cover;
    transition: transform 0.6s ease;
}

.horizontal-card:hover .post-cover img {
    transform: scale(1.1);
}

/* ========== 图片在右边 + 斜切线 ========== */
.horizontal-card.image-right {
    background: linear-gradient(135deg, var(--card-bg) 0%, var(--card-bg-alt) 100%);
}

.horizontal-card.image-right .post-content {
    order: 1;
    padding-right: 80px;
    clip-path: polygon(
        0 0, 
        calc(100% - var(--skew-width)) 0, 
        100% 100%, 
        0 100%
    );
}

.horizontal-card.image-right .post-cover {
    order: 2;
    clip-path: polygon(
        var(--skew-width) 0, 
        100% 0, 
        100% 100%, 
        0 100%
    );
    margin-left: calc(var(--skew-width) * -1);
    margin-right: calc(var(--skew-width) * -1);
    width: calc(42% + var(--skew-width)) !important;
    flex: 0 0 calc(42% + var(--skew-width)) !important;
    max-width: calc(42% + var(--skew-width)) !important;
}

/* ========== 图片在左边 + 斜切线 ========== */
.horizontal-card.image-left {
    background: linear-gradient(225deg, var(--card-bg) 0%, var(--card-bg-alt) 100%);
}

.horizontal-card.image-left .post-content {
    order: 2;
    padding-left: 80px;
    clip-path: polygon(
        var(--skew-width) 0, 
        100% 0, 
        100% 100%, 
        0 100%
    );
}

.horizontal-card.image-left .post-cover {
    order: 1;
    clip-path: polygon(
        0 0, 
        calc(100% - var(--skew-width)) 0, 
        100% 100%, 
        0 100%
    );
    margin-right: calc(var(--skew-width) * -1);
    margin-left: calc(var(--skew-width) * -1);
    width: calc(42% + var(--skew-width)) !important;
    flex: 0 0 calc(42% + var(--skew-width)) !important;
    max-width: calc(42% + var(--skew-width)) !important;
}

/* 第一张卡片距离顶部增加间距 */
.horizontal-card:first-child {
    margin-top: 32px;
}

/* ========== 响应式适配 ========== */
@media screen and (max-width: 768px) {
    .horizontal-card,
    .horizontal-card.image-left,
    .horizontal-card.image-right {
        flex-direction: column;
        height: auto;
        margin-bottom: 28px;
    }

    .horizontal-card .post-content,
    .horizontal-card.image-left .post-content,
    .horizontal-card.image-right .post-content {
        width: 100%;
        flex: none;
        max-width: 100%;
        padding: 24px;
        order: 2;
        clip-path: none;
    }

    .horizontal-card.image-left .post-cover,
    .horizontal-card.image-right .post-cover {
        width: 100% !important;
        flex: none !important;
        max-width: 100% !important;
        min-width: auto;
        height: 220px;
        order: 1;
        margin: 0 !important;
        clip-path: polygon(0 0, 100% 0, 100% 85%, 0 100%);
    }
}

_config.anzhiyu.yml调用自定义horizontal-card.css

inject:
  head:
    # 自定义css
    ...
    -

_config.anzhiyu.yml中使用新的文章卡片样式，建议添加article_double_row之后

...

# 首页双栏显示
article_double_row: true

# 文章卡片样式: default | horizontal
home_card_style: horizontal

...

anzhiyu主题侧边栏添加访客信息

Sun, 12 Apr 2026 15:15:45 GMT

前言

博客是写在网上的日记，但总有人悄悄路过。

侧边栏那个小小的卡片，它会尝试获取你的大致位置（不精确到门牌号，只是城市和距离），然后告诉博主：你离我多少公里，此刻是早安、午安还是晚安。

代码不多，但花了不少心思：多 API 降级、PJAX 兼容、距离计算、时间问候……甚至为了不泄露隐私，全程只使用公开的 IP 地理服务。

如果你是安知鱼主题的用户，可以直接照搬；如果你用其他主题，改改选择器也能用。

正文

文件路径

blog/
├── themes/
│   └── anzhiyu/                    
│       ├── layout/                 
│       │   ├── includes/           
│       │   │   └── widget/         
│       │   │       └── card_welcome.pug 
│       │   │       └── index.pug                      
├── source/                        
│   └── cdn/                        
│       └── css/
│       │   └── welcome.css
│       └── js/
│           └── welcome.js
└── ...

新建card_welcome.pug

.card-widget.card-welcome
  .card-content
    .item-headline
      i.fas.fa-map-marker-alt
    #welcome-info(style="min-height: 100px; display: flex; align-items: center; justify-content: center;")
      .loading-spinner
        i.fas.fa-spinner.fa-spin
        |  正在定位...

修改index.pug

#aside-content.aside-content
  //- post
  if is_post()
    - const tocStyle = page.toc_style_simple
    - const tocStyleVal = tocStyle === true || tocStyle === false ? tocStyle : theme.toc.style_simple
    if showToc && tocStyleVal
      .sticky_layout
        include ./card_post_toc.pug
    else
      !=partial('includes/widget/card_author', {}, {cache: true})
      !=partial('includes/widget/card_announcement', {}, {cache: true})
      
      // 添加访客信息卡片（公告下面）
      !=partial('includes/widget/card_welcome', {}, {cache: true})
      
      !=partial('includes/widget/card_weixin', {}, {cache: true})
      !=partial('includes/widget/card_top_self', {}, {cache: true})
      .sticky_layout
        if showToc
          include ./card_post_toc.pug
        !=partial('includes/widget/card_recent_post', {}, {cache: true})
        !=partial('includes/widget/card_ad', {}, {cache: true})
  else
    //- page
    !=partial('includes/widget/card_author', {}, {cache: true})
    !=partial('includes/widget/card_announcement', {}, {cache: true})
    
    // 添加访客信息卡片（公告下面）
    !=partial('includes/widget/card_welcome', {}, {cache: true})
    
    !=partial('includes/widget/card_weixin', {}, {cache: true})
    !=partial('includes/widget/card_top_self', {}, {cache: true})
    !=partial('includes/widget/card_categories', {}, {cache: true})  

    .sticky_layout
      if showToc
        include ./card_post_toc.pug
      .card-widget
        !=partial('includes/widget/card_ad', {}, {cache: true})
        !=partial('includes/widget/card_tags', {}, {cache: true})
        !=partial('includes/widget/card_archives', {}, {cache: true})
        !=partial('includes/widget/card_webinfo', {}, {cache: true})
      !=partial('includes/widget/card_bottom_self', {}, {cache: true})

新建welcome.js

// 使用 IIFE 避免全局污染
(function() {
    // 标记是否已经获取过 IP 信息（当前会话内只获取一次即可）
    let ipInfoLoaded = false;
    let cachedHTML = null;

    const fetchIpInfo = async () => {
        const welcomeInfo = document.querySelector('#welcome-info');
        if (!welcomeInfo) return;
        
        // 如果已经加载过，直接恢复缓存的内容
        if (ipInfoLoaded && cachedHTML) {
            welcomeInfo.innerHTML = cachedHTML;
            return;
        }
        
        // 显示加载状态
        welcomeInfo.innerHTML = ' 定位中...
';
        
        // 备用 API 列表（ipinfo.io 在国内可能被拦截，放在后面）
        const apis = [
            { 
                url: 'https://api.ip.sb/geoip', 
                parser: (d) => ({
                    country: d.country,
                    region: d.region,
                    city: d.city,
                    loc: d.latitude && d.longitude ? `${d.latitude},${d.longitude}` : null
                })
            },
            {
                url: 'https://ipapi.co/json/',
                parser: (d) => ({
                    country: d.country_code,
                    region: d.region,
                    city: d.city,
                    loc: d.latitude && d.longitude ? `${d.latitude},${d.longitude}` : null
                })
            },
            {
                url: 'https://ipinfo.io/json',
                parser: (d) => ({
                    country: d.country,
                    region: d.region,
                    city: d.city,
                    loc: d.loc
                })
            }
        ];
        
        let data = null;
        
        for (const api of apis) {
            try {
                const controller = new AbortController();
                const timeout = setTimeout(() => controller.abort(), 3000);
                
                const res = await fetch(api.url, { 
                    signal: controller.signal,
                    headers: { 'Accept': 'application/json' }
                });
                clearTimeout(timeout);
                
                if (res.ok) {
                    const raw = await res.json();
                    data = api.parser(raw);
                    break;
                }
            } catch (e) {
                continue;
            }
        }
        
        // 渲染内容
        if (data) {
            const { country, region, city, loc } = data;
            const [lat, lng] = loc ? loc.split(',').map(Number) : [];
            
            const myLat = 31.707754;
            const myLng = 119.825873;
            const dist = (lat && lng) ? calculateDistance(lng, lat, myLng, myLat) : null;
            
            const location = country === "CN" || country === "China" 
                ? `${region || ''} ${city || ''}`.trim() 
                : (country || '地球');
            
            cachedHTML = `
                
                    欢迎来自 ${location || '神秘星球'} 的道友 💖
                    ${dist ? `距博主约 ${dist} 公里
` : ''}
                    ${getTimeGreeting()}
                
            `;
            ipInfoLoaded = true;
            welcomeInfo.innerHTML = cachedHTML;
        } else {
            cachedHTML = `
                
                    🎉 欢迎来到我的博客！
                    ${getTimeGreeting()}
                
            `;
            ipInfoLoaded = true;
            welcomeInfo.innerHTML = cachedHTML;
        }
    };

    const calculateDistance = (lng1, lat1, lng2, lat2) => {
        if (!lat1 || !lng1 || !lat2 || !lng2) return null;
        const R = 6371;
        const rad = Math.PI / 180;
        const dLat = (lat2 - lat1) * rad;
        const dLon = (lng2 - lng1) * rad;
        const a = Math.sin(dLat/2) ** 2 + Math.cos(lat1 * rad) * Math.cos(lat2 * rad) * Math.sin(dLon/2) ** 2;
        return Math.round(R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)));
    };

    const getTimeGreeting = () => {
        const hour = new Date().getHours();
        if (hour < 6) return "It's late, pay attention to rest 🌙";
        if (hour < 12) return "Good morning, start your day. ☀️";
        if (hour < 18) return "Good afternoon. Good work. ☕";
        return "Good evening. May you have a good mood. 🌆";
    };

    // ===== 初始化策略 =====
    
    // 1. 首次加载
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', fetchIpInfo);
    } else {
        fetchIpInfo();
    }

    // 2. 安知鱼主题 PJAX 事件（关键）
    // 安知鱼使用 pjax:complete，但 footer 不刷新，所以需要手动恢复内容
    document.addEventListener('pjax:complete', () => {
        // PJAX 完成后，检查 welcome-info 是否存在
        setTimeout(() => {
            const welcomeInfo = document.querySelector('#welcome-info');
            if (welcomeInfo) {
                if (cachedHTML && ipInfoLoaded) {
                    // 已经有缓存，直接恢复
                    welcomeInfo.innerHTML = cachedHTML;
                } else {
                    // 首次或缓存丢失，重新获取
                    fetchIpInfo();
                }
            }
        }, 100); // 延迟确保 DOM 已更新
    });

    // 3. 浏览器前进/后退按钮
    window.addEventListener('popstate', () => {
        setTimeout(() => {
            const welcomeInfo = document.querySelector('#welcome-info');
            if (welcomeInfo && cachedHTML && ipInfoLoaded) {
                welcomeInfo.innerHTML = cachedHTML;
            }
        }, 100);
    });

})();

新建welcome.css

.card-welcome .item-headline i {
    color: #4dabf7;
  }
  
  .card-welcome #welcome-info {
    color: var(--anzhiyu-fontcolor);
    text-align: center;
    padding: 15px;
  }
  
  .card-welcome #welcome-info .loading {
    font-size: 14px;
  }
  
  .card-welcome #welcome-info .loading i {
    margin-right: 8px;
  }
  
  .card-welcome .welcome-content .location {
    color: #ffd700;
    font-weight: bold;
    font-size: 16px;
  }
  
  .card-welcome .welcome-content .distance {
    color: #4dabf7;
    font-weight: bold;
  }
  
  .card-welcome .welcome-content .ip-address {
    font-size: 12px;
    opacity: 0.7;
    margin-top: 5px;
  }
  
  .card-welcome .welcome-content .greeting {
    font-size: 14px;
    line-height: 1.5;
    opacity: 0.95;
    letter-spacing: 0.3px;
  }

_config.anzhiyu.yml 调用自定义 welcome.css和welcome.js

inject:
  head:
    # 自定义css
    ...
    - 
    ...
 
  bottom:
    # 自定义js
    ...
    - 
    ...

PostgreSQL基础命令

Sat, 04 Apr 2026 08:48:13 GMT

常用命令说明

序号	操作	命令
1	列出所有数据库	\l
2	列出数据库中所有的表	\d
3	显示指定表的结构	\d table_name
4	列出所有的帮助命令	?
5	列出数据库中所有的索引	\di
6	列出数据库中所有的view	\dv
7	sql命令帮助	\h
8	退出连接	\q
9	切换到指定的数据库	\c [database_name]
10	显示当前数据库和用户	\c
11	显示客户端的连接信息	\conninfo
12	显示所有用户	\du
13	显示数据库中的schema	\dn
14	显示字符集	\encoding
15	执行sql文件	\i mydb.sql
16	扩展展示信息，相当于MySQL中的\G	\x
17	将下一条sql执行结果导入文件中	\o /opt/test.txt

进阶命令

#查看复制状态，master执行
select client_addr, state, sent_lsn, flush_lsn, sync_state from pg_stat_replication;

#查看延迟，slave执行
select pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn();

登陆命令

1	psql -h 172.16.0.2 -p 5432 -U postgres -d 数据库名 -W

-h #数据库所在的IP地址
-p #（默认5432）数据库的监听端口
-U #用户名
-d #数据库名称
-W#指示 psql 命令在连接数据库时强制提示输入密码

PG状态管理

1 2	pg_ctl start/status/stop systemctl start/status/stop postgresql-16

PostgreSQL 16.3中复制槽的配置

Wed, 01 Apr 2026 08:52:43 GMT

前言

复制槽（Replication Slot）是数据库（如 PostgreSQL）中用于保障主从复制数据一致性与安全性的核心机制，它通过在主库上为每个从库建立一个持久的状态记录点，强制主库保留该从库尚未确认接收的 WAL（预写日志），从而防止因日志过早被清理而导致从库断连后无法继续同步；简单来说，它就像一根“安全绳”，确保即使从库长时间离线或网络中断，重新连接后也能无缝续传缺失的数据，避免主从数据出现不可修复的断层。

流复制的配置不在做过多的缀述，直接基于之前搭建的流式复制配置复制槽，

配置

首先在主库上创建物理复制槽

#创建
select pg_create_physical_replication_slot('demo_slot', true);
#查询
select * from pg_replication_slots;

然后再去备库配置连接信息，由于使用的是 PostgreSQL 16.3 的搭建的流式复制，故直接在postgresql.auto.conf中配置

1 2	#在postgresql.auto.conf中添加 primary_slot_name = 'demo_slot'

最后重启备库后，在主库查看slot的状态，active=true的话说明slot已经被激活

字段名	含义与解释
`slot_name`	槽的名称。这是你创建槽时指定的唯一标识符，例如你的 `demo_slot`在配置主从连接 (`primary_slot_name`) 时会用到它。
`plugin`	插件名称。 • 如果是物理复制 (Physical)，此值为 • 如果是逻辑复制 (Logical)，这里会显示使用的输出插件名，如 `pgoutput`, `test_decoding`等。
`slot_type`	槽的类型。 • `physical`: 用于流复制备库（Standby）。 • `logical`: 用于逻辑解码或逻辑订阅（Logical Subscription）。
`datoid`	数据库 OID。仅对逻辑复制槽有效，表示该槽关联的数据库 ID。物理复制槽与此无关，所以是。
`database`	数据库名称。同上，仅对逻辑复制槽有效，显示关联的数据库名。
`temporary`	是否为临时槽。 • `True`: 临时槽，当创建它的会话结束时自动删除。 • `False`: 持久化槽，重启后依然存在（你的 `demo_slot`就是这种）。
`active`	是否活跃。 • `True`: 表示有一个备库或客户端正连接并使用这个槽（你的情况）。 • `False`: 槽存在但没人用。如果长期为 False，说明备库断连了，需要检查网络或配置。
`active_pid`	活跃进程的 PID。显示主库上哪个后端进程（Walsender）正在服务这个槽。你的 `79803`就是那个进程的 ID。可以用 `SELECT * FROM pg_stat_activity WHERE pid = 79803;`查看该进程详情。
`xmin`	事务 ID 下限。仅对逻辑复制槽有意义。表示为了防止逻辑解码所需的事务快照被清理，系统必须保留的最早事务 ID。物理复制槽通常为。
`catalog_xmin`	目录事务 ID 下限。仅对逻辑复制槽有意义。类似 `xmin`，但是针对系统目录表的变更。
`restart_lsn`	重启 LSN (Log Sequence Number) ⭐这是物理复制最重要的字段。它表示：“从这个位置开始的 WAL 日志，我都还没确认备库收到了，所以主库绝对不能删除这些日志”。随着备库不断确认接收，这个值会向后推进。
`confirmed_flush_lsn`	已确认刷新的 LSN。仅对逻辑复制有效。表示逻辑订阅者已经成功处理并重放到的位置。物理复制槽此值为。
`wal_status`	WAL 日志状态。 • `reserved`: 正常状态，表示槽正在保留 WAL 日志。 • `lost`: 警告状态！表示槽需要的 WAL 日志已经被主库清理掉了，复制将中断，需要重新做基础备份。
`safe_wal_size`	安全的 WAL 大小。估算值，表示在当前状态下，主库还能安全地生成多少 WAL 日志而不会触发 `wal_status = 'lost'`。如果这个值变成负数，说明已经很危险了。
`two_phase`	是否支持两阶段提交。仅对逻辑复制槽有效。如果为 `True`，表示该槽可以复制两阶段提交（PREPARE TRANSACTION）的事务。
`conflicting`	是否存在冲突。仅对逻辑复制槽有效。如果在解码过程中遇到无法解决的冲突（比如表结构不一致），这里会标记为 `True`。

Docker基础命令速查指南：从入门到实践

Thu, 26 Mar 2026 08:38:58 GMT

Docker是什么？

“Docker”一词指代了多个概念，包括开源社区项目、开源项目使用的工具、主导支持此类项目的公司 Docker Inc.，以及该公司官方支持的工具。这些技术和公司的同名可能会造成混淆。

以下简要说明 Docker 以便区分：

IT 软件”Docker”是支持创建和使用 Linux® 容器的容器化技术。
开源 Docker 社区致力于改进这类技术，并免费提供给所有用户，使之获益。
Docker Inc. 公司凭借 Docker 社区产品起家，主要负责提升社区版本的安全性，并将技术进步与广大技术社区分享。此外，它还专门对这些技术产品进行完善和安全固化，以服务于企业客户。
借助 Docker，您可将容器当做轻巧、模块化的虚拟机来使用。同时，您还将获得高度灵活性，实现对容器的高效创建、部署及复制，并在环境之间迁移它们，从而有助于您针对云来优化应用。

镜像管理

搜索镜像

1	docker search 镜像的名字

拉取镜像

1	docker pull 镜像的名字

查看本地镜像

docker images 
docker image ls
docker images -q 只列出镜像的id
docker images --format “{{.ID}}--{{.Repository}}” 格式化显示镜像
docker images --format “ table {{.ID}}\t{{.Repository}}\t{{.Tag}}" 以表格形式显示

删除镜像

1
2
3

docker rmi 镜像id
批量删除镜像
docker rmi `docker images -qa`

导入镜像

#导入打包后的镜像
docker image load -i /opt/centos7.8.2003.tar   
#导入打包压缩后的镜像
zstd -dc /opt/centos-stream9.tar.zst | docker image load

导出镜像

#打包
docker image save centos-stream9:cs9 > /opt/centos-stream9.tar
#打包并压缩
docker image save centos-stream9:cs9 | zstd -o /opt/centos-stream9.tar.zst

#注意：打包时会占用临时空间

查看镜像详细信息

1	docker image inspect 镜像id

查看一个镜像的历史

docker history [OPTIONS] IMAGE

#OPTIONS
--no-trunc：显示完整命令（默认会截断长命令）
-q：只显示镜像 ID
--format：自定义输出格式（比如只关心大小）

容器管理

启动容器

docker run  -p 85:80 nginx   //容器的端口映射85是宿主机的端口，80是容器的端口
docker run  -p 0.0.0.0:85:80 nginx   #只做ipv4地址端口映射
docker run  -P nginx  随机端口映射
docker run - it --rm  -d --name test  --ip 192.168.159.152 容器id/名字 bash/sh  
        -i 交互式命令操作
        -t 开启一个终端
        bash 在进入容器后执行的命令  //其实就相当于shell解释器
        --rm  容器挂了后自动删除容器记录
        -d 在后台运行
        --name test 给容器起一个名字叫test
        --restart=always  //容器挂了后自动重启
        --net     //网桥名字
        --ip     //分配容器的ip
        --cups=0.5  //限制cpu的使用率
        --privileged=true  //表示启用容器的超级权限，启用超级权限的时候需要以/usr/sbin/init命令启动不然超级权限不会生效

注意事项：

docker run 等于创建加启动，如果镜像不存在在本地则会去下载镜像
容器内的进程必须处于前台运行状态，否则容器会直接退出
如果容器内，什么事也不做，容器也会挂掉，容器内，必须有一个进程在前台运行，//例如docker run nginx 容器会直接挂掉

进入容器

1	docker exec -it 容器id bash //进入正在运行的容器

查看运行的容器

docker ps

查看停止的容器

1	docker ps -a

容器的重启、停止、启动

1	docker restart/stop/start 容器id

查看容器的详细信息

1	docker container inspect 容器id

查看容器端口转发情况

1	docker port 容器id

查看容器内进程信息

1	docker top 容器id

查看容器内资源

1	docker stats 容器id

查看容器的具体信息

1	docker inspecet 容器id

传输本地文件到容器中

1	docker cp 本地文件路径容器ID:容器中的存储路径

传输容器中的文件到本地

1	docker cp 容器ID:容器中的路径本地存储路径

退出容器

exit

只删除容器，volume保留

1
2
3

docker rm 容器id
#强制删除容器
docker rm -f 容器id

阻塞容器

1 2	#用于阻塞docker容器，并在容器退出是打印退出码，当容器不在运行的时候，直接输出0；可以用来监控容器是否正常退出 docke wait 容器ID/容器名字

删除容器，同时删除volume

1 2	docker rm -v 容器ID docker rm --volumes 容器ID

查看容器资源使用情况

1	docker stats

容器打包成镜像

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

docker commit -a 'LML' -m 'This is a container image'  容器ID  容器打包后的镜像名字:标签 
Option功能
-a指定新镜像作者
-c使用 Dockerfile 指令来创建镜像
-m提交生成镜像的说明信息
-p在 commit 时，将容器暂停|

容器打包成tar包

1
2
3

docker save -o tar包名称.tar 待打包镜像名称:待打包镜像版本
演示：
docker save -o mysql-lml-docker.tar mysql-lml-docker:v1.0

tar包载入镜像

1
2
3

docker load [OPTIONS] tar包名称.tar
演示：
docker load -i mysql-lml-docker.tar

日志管理

查看容器日志

所有日志
docker logs 容器id
相当于tail -f，实时的刷新日志
docker logs -f 容器id

网络管理

列出所有网桥

1	docker network ls

查看网络信息

1	docker network inspect 网络类型

创建新的网桥

1	docker network create --subnet=192.168.159.0/24 NetTest

删除创建的网桥

1	docker network rm net_name

将容器加入自建网络中

1	docker network connect 网络名称容器名称

将容器退出自建网络中

1	docker network disconnect 网络名称容器名称

命名卷管理

列出所有的volume

1	docker volume ls

删除未使用的volume

1	docker volume prune

查看volume信息

1	docker volume inspect 命名卷名字

删除volume

1	docker volume rm 命名卷的卷名

创建volume

1	docker volume create 命名卷名字

进阶命令

查看所有的容器和镜像大小

1	docker system df

回收悬空的镜像

1	docker image prune -a

删除所有已停用的容器

1	docker container prune

回收孤儿卷（无容器使用）

1	docker volume prune

批量删除（网络，数据卷，镜像…）

1
2
3

docker system prune        # 仅中间层 + 停止容器
docker system prune -a     # 再加“无用”镜像
docker system prune -a --volumes  # 连无用卷一起

启停全部容器

1	docker stop/start $(docker ps -aq -f "status=running/exited/created/paused")

Hexo网站地图生成与百度主动推送

Sun, 01 Mar 2026 10:43:45 GMT

网站地图生成

安装插件

在 Hexo 站点根目录执行：

1	npm install hexo-generator-sitemap --save

配置 _config.yml

编辑 Hexo 根目录的 _config.yml 文件，添加以下配置：

# 站点地图配置
sitemap:
  path: sitemap.xml
  # 可选参数
  priority: 0.5        # 页面优先级，范围 0.0-1.0
  changefreq: daily    # 更新频率：always/hourly/daily/weekly/monthly/yearly/never
  lastmod: true        # 是否包含最后修改时间
  tags: true           # 是否包含标签页
  categories: true     # 是否包含分类页

注意：确保 _config.yml 中的 url 配置正确，站点地图会基于这个 URL 生成完整链接：

# URL 配置（必须正确设置）
url: https://images.mingliangstar.com
root: /
permalink: :year/:month/:day/:title/

生成站点地图

执行生成命令：

1	hexo clean && hexo generate

生成后会在 public/ 目录下创建文件：sitemap.xml

百度主动推送

1. 安装插件

在 Hexo 站点根目录下执行：

1	npm install hexo-baidu-url-submit --save

2. 获取百度 Token

访问百度搜索资源平台
注册/登录并添加你的网站
进入 站点管理 → 资源提交 → 链接提交 → 主动推送(实时)
找到推送接口地址，复制 token= 后面的字符串

3. 修改站点配置

编辑 Hexo 根目录的 _config.yml，添加以下配置：

# 百度主动推送配置
baidu_url_submit:
  count: 10              # 提交最新的多少个链接（默认200）
  host: images.mingliangstar.com  # 在百度站长平台注册的域名（不含 http/https）
  token: your_token_here  # 你的百度推送密钥（不要泄露！）
  path: baidu_urls.txt    # 生成的链接文件路径（默认即可）

注意：host 字段不要带 http:// 或 https://，只需要纯域名。

4. 添加部署配置

在 _config.yml 的 deploy 部分添加推送类型：

1 2	deploy: - type: baidu_url_submitter # 添加这一行

如果有多个部署目标，确保每个 type 前都有 - 。

5. 验证配置

执行部署命令：

1	hexo clean && hexo generate && hexo deploy

推送成功后会显示下述信息：

blog

手动提交

手动提交可以参考之前写的这篇文章

网站提交搜索引擎

Hexo中字体的引入与压缩

Fri, 13 Feb 2026 07:58:51 GMT

引入tff字体

本文中涉及的文件没有的话再对应的目录下创建即可

首先，找一个你喜欢的字体。你可以在一些网站上免费下载。下载完之后，把那个.ttf格式的文件放到你网站根目录下的/source/fonts文件夹里。

免费字体下载大全，可免费商用中文字体一览表 - 猫啃网

接下来，你需要把下面的代码加到/source/css/custom.css文件里，这样就可以引入字体了。

@font-face {
  font-family: 'BailuFeiYun';
  src: url('/fonts/BailuFeiYu.ttf') format('truetype'); 
  font-weight: normal;
  font-style: normal;
  font-display: swap;  /* 关键：防止闪烁，先显示后备字体 */
}

记得在_config.anzhiyu.yml文件里加上custom.css，并且设置一下“# Global font settings”那部分。

1	<link rel="stylesheet" href="/css/custom.css">

最后一步就是清理缓存，然后重新生成就行了。

1 2	hexo clean hexo generate

tff转换woff2

.ttf字体文件有时候会很大，这样会让网站加载变慢。为了解决这个问题，你可以把.ttf文件转换成.woff2格式，这种格式的文件更小，加载更快。你可以在一些免费的在线网站上完成这个转换。

TTF to WOFF2 | CloudConvert

记得改一下这里的代码。

@font-face {
  font-family: 'BailuFeiYun';
  src: url('/fonts/BailuFeiYu.woff2') format('woff2'),
       url('/fonts/BailuFeiYun.ttf') format('truetype'); 
  font-weight: normal;
  font-style: normal;
  font-display: swap;  /* 关键：防止闪烁，先显示后备字体 */
}

字体压缩

如果你引用了*.woff2格式的字体文件，但网站加载还是很慢，那可能就得考虑压缩字体了——可以用字蛛（font-spider）这个工具。

1、安装字蛛

# 全局安装
npm install font-spider -g

# 验证安装
font-spider --version

2、准备工作目录

# 创建工作目录
mkdir font-spider-work
cd font-spider-work

# 创建必要文件
touch index.html
mkdir -p source/fonts

# 放入原字体
cp /source/fonts/BailuFeiYun.ttf source/fonts/

3、建一个index.html文件，在里面放上你博客要用的所有字体。




<head>
    "UTF-8">
    Font Spider
    



    "font-test">
        
        首页文章归档分类标签友链关于
        技术分享HexoWordPress建站心路
        上一篇下一篇打赏作者复制链接
        猫笔千锤岁月长啃文万遍见真功
        

        
        ，。！？、；：" " ' ' （）《》【】… — ～ · ｜

        
        abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789

        
        安知鱼 白路飞云 手写体 博客 笔记 技术 生活 随笔

4、执行压缩

1	font-spider index.html

最后，只需要在custom.css文件里加入压缩后的字体就行了。

压缩脚本

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Hexo 博客字体压缩脚本 - 动态完整版
扫描汉字、英文、数字、标点
"""

import os
import re
import sys
import yaml
import json


def extract_chars_from_file(filepath, skip_comments=False):
    """从文件提取所有字符（汉字、英文、数字、标点）"""
    try:
        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
            content = f.read()
            
            # 如果需要过滤注释（YAML 文件）
            if skip_comments:
                lines = content.split('\n')
                content = '\n'.join([line for line in lines if not line.strip().startswith('#')])
            
            chars = set()
            
            # 1. 汉字
            chars.update(re.findall(r'[\u4e00-\u9fa5]', content))
            
            # 2. 英文字母（大小写）
            chars.update(re.findall(r'[a-zA-Z]', content))
            
            # 3. 数字
            chars.update(re.findall(r'[0-9]', content))
            
            # 4. 常用标点符号
            # 中文标点
            chars.update(re.findall(r'[，。！？、；：""''（）《》【】…—～·｜「」『』【】]', content))
            # 英文标点
            chars.update(re.findall(r'[.,!?;:\'\"()\[\]{}@#$%^&*+=_\-\\/<>~`]', content))
            
            return chars
            
    except Exception as e:
        print(f"读取文件失败 {filepath}: {e}")
        return set()


def extract_chars_from_json_yaml(filepath):
    """从 JSON/YAML 文件递归提取所有字符串中的字符"""
    chars = set()
    try:
        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
            content = f.read()
            
            # 尝试解析为 JSON 或 YAML
            data = None
            try:
                data = json.loads(content)
            except:
                try:
                    data = yaml.safe_load(content)
                except:
                    pass
            
            def extract_strings(obj):
                if isinstance(obj, str):
                    result = set()
                    # 汉字
                    result.update(re.findall(r'[\u4e00-\u9fa5]', obj))
                    # 英文
                    result.update(re.findall(r'[a-zA-Z]', obj))
                    # 数字
                    result.update(re.findall(r'[0-9]', obj))
                    # 标点
                    result.update(re.findall(r'[，。！？、；：""''（）《》【】…—～·｜「」『』【】.,!?;:\'\"()\[\]{}@#$%^&*+=_\-\\/<>~`]', obj))
                    return result
                elif isinstance(obj, list):
                    result = set()
                    for item in obj:
                        result.update(extract_strings(item))
                    return result
                elif isinstance(obj, dict):
                    result = set()
                    for key, value in obj.items():
                        result.update(extract_strings(key))
                        result.update(extract_strings(value))
                    return result
                return set()
            
            if data:
                chars.update(extract_strings(data))
            else:
                # 解析失败，直接正则提取
                chars.update(extract_chars_from_file(filepath))
                
    except Exception as e:
        print(f"读取失败 {filepath}: {e}")
    
    return chars


def extract_title_from_md(filepath):
    """只提取 Markdown 文件的 Front-matter title"""
    try:
        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
            content = f.read()
            
            # 匹配 Front-matter
            fm_match = re.match(r'^---\s*\n(.*?)\n---', content, re.DOTALL)
            title = ''
            if fm_match:
                try:
                    fm = yaml.safe_load(fm_match.group(1))
                    title = str(fm.get('title', ''))
                except:
                    pass
            
            # 备用：正则提取 title: xxx
            if not title:
                title_match = re.search(r'^title:\s*(.+)$', content, re.MULTILINE)
                if title_match:
                    title = title_match.group(1).strip().strip('"\'')
            
            # 提取所有字符
            chars = set()
            chars.update(re.findall(r'[\u4e00-\u9fa5]', title))
            chars.update(re.findall(r'[a-zA-Z]', title))
            chars.update(re.findall(r'[0-9]', title))
            chars.update(re.findall(r'[，。！？、；：""''（）《》【】…—～·｜「」『』【】.,!?;:\'\"()\[\]{}@#$%^&*+=_\-\\/<>~`]', title))
            
            return chars
            
    except Exception as e:
        print(f"读取失败 {filepath}: {e}")
        return set()


def get_dynamic_fixed_chars(hexo_root):
    """从配置文件动态读取固定字符"""
    chars = set()
    
    # 1. 从站点配置 _config.yml 读取
    site_config = os.path.join(hexo_root, '_config.yml')
    if os.path.exists(site_config):
        print(f"  读取站点配置: _config.yml")
        config_chars = extract_chars_from_file(site_config, skip_comments=True)
        chars.update(config_chars)
        print(f"    -> {len(config_chars)} 字符")
    
    # 2. 从主题配置 _config.anzhiyu.yml 读取（过滤注释）
    theme_config = os.path.join(hexo_root, '_config.anzhiyu.yml')
    if os.path.exists(theme_config):
        print(f"  读取主题配置: _config.anzhiyu.yml")
        config_chars = extract_chars_from_file(theme_config, skip_comments=True)
        chars.update(config_chars)
        print(f"    -> {len(config_chars)} 字符")
    
    # 3. 从主题语言文件读取
    theme_lang_dir = os.path.join(hexo_root, 'themes', 'anzhiyu', 'languages')
    if os.path.exists(theme_lang_dir):
        print(f"  读取主题语言文件:")
        for lang_file in os.listdir(theme_lang_dir):
            if lang_file.endswith(('.yml', '.yaml')):
                filepath = os.path.join(theme_lang_dir, lang_file)
                lang_chars = extract_chars_from_file(filepath, skip_comments=True)
                if lang_chars:
                    chars.update(lang_chars)
                    print(f"    {lang_file} -> {len(lang_chars)} 字符")
    
    return chars


def scan_directory_full(directory, chars_set, skip_dirs=None, depth=0):
    """递归扫描目录下所有文件"""
    if skip_dirs is None:
        skip_dirs = ['node_modules', '.git', 'images', 'img', 'fonts', 'css', 'js']
    
    if not os.path.exists(directory):
        return 0, 0
    
    file_count = 0
    total_chars = 0
    
    prefix = "  " * depth
    
    for root, dirs, files in os.walk(directory):
        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith('.')]
        
        for file in files:
            filepath = os.path.join(root, file)
            rel_path = os.path.relpath(filepath, directory)
            
            file_chars = set()
            
            if file.endswith('.md'):
                file_chars = extract_chars_from_file(filepath)
            elif file.endswith(('.json', '.yml', '.yaml')):
                file_chars = extract_chars_from_json_yaml(filepath)
            elif file.endswith(('.html', '.htm', '.txt')):
                file_chars = extract_chars_from_file(filepath)
            
            if file_chars:
                chars_set.update(file_chars)
                file_count += 1
                total_chars += len(file_chars)
                print(f"{prefix}  {rel_path} -> {len(file_chars)} 字符")
    
    return file_count, total_chars


def generate_char_file(output_path, hexo_root):
    """生成字符文件"""
    print("=" * 60)
    print("Hexo 博客字体压缩工具 - 动态完整版")
    print("=" * 60)
    
    chars = set()
    
    # 1. 文章目录：只扫描标题
    posts_dir = os.path.join(hexo_root, 'source', '_posts')
    if os.path.exists(posts_dir):
        print(f"\n📁 扫描文章标题(仅title): {posts_dir}")
        count = 0
        for root, dirs, files in os.walk(posts_dir):
            dirs[:] = [d for d in dirs if d not in ['node_modules', '.git']]
            for file in files:
                if file.endswith('.md'):
                    filepath = os.path.join(root, file)
                    title_chars = extract_title_from_md(filepath)
                    chars.update(title_chars)
                    count += 1
        print(f"  扫描了 {count} 篇文章，提取 {len(chars)} 个独特字符")
    
    # 2. 其他页面目录：全内容扫描
    source_dir = os.path.join(hexo_root, 'source')
    if os.path.exists(source_dir):
        print(f"\n📁 扫描页面目录(全内容递归):")
        
        for item in os.listdir(source_dir):
            if item in ['_posts', 'images', 'img', 'fonts', 'css', 'js']:
                continue
            
            item_path = os.path.join(source_dir, item)
            
            if os.path.isdir(item_path):
                print(f"\n  📂 {item}/")
                file_count, total_chars = scan_directory_full(item_path, chars, depth=1)
                print(f"    合计: {file_count} 个文件，{total_chars} 字符")
    
    # 3. 扫描 _data 目录
    data_dir = os.path.join(hexo_root, 'source', '_data')
    if os.path.exists(data_dir):
        print(f"\n📁 扫描数据目录(_data):")
        file_count, total_chars = scan_directory_full(data_dir, chars, depth=1)
        print(f"    合计: {file_count} 个文件，{total_chars} 字符")
    
    # 4. 动态读取配置文件
    print(f"\n📁 动态读取配置文件:")
    fixed_chars = get_dynamic_fixed_chars(hexo_root)
    chars.update(fixed_chars)
    print(f"  配置文件共提取: {len(fixed_chars)} 字符")
    
    # 5. 排序并保存
    # 按字符类型排序：汉字 -> 英文 -> 数字 -> 标点
    hanzi = sorted([c for c in chars if '\u4e00' <= c <= '\u9fa5'])
    english = sorted([c for c in chars if c.isalpha()])
    digits = sorted([c for c in chars if c.isdigit()])
    others = sorted([c for c in chars if not ('\u4e00' <= c <= '\u9fa5' or c.isalnum())])
    
    sorted_chars = ''.join(hanzi + english + digits + others)
    
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(sorted_chars)
    
    print(f"\n" + "=" * 60)
    print(f"✅ 共收集 {len(chars)} 个独特字符")
    print(f"   - 汉字: {len(hanzi)} 个")
    print(f"   - 英文: {len(english)} 个")
    print(f"   - 数字: {len(digits)} 个")
    print(f"   - 标点/其他: {len(others)} 个")
    print(f"💾 已保存到: {output_path}")
    
    preview = sorted_chars[:100]
    print(f"\n📋 字符预览: {preview}...")
    
    return sorted_chars


def subset_font(input_font, output_font, chars_file):
    """使用 fonttools 子集化字体"""
    try:
        from fontTools.subset import main as subset_main
    except ImportError:
        print("\n❌ 缺少 fonttools，正在安装...")
        os.system(f"{sys.executable} -m pip install fonttools brotli zopfli")
        from fontTools.subset import main as subset_main
    
    print(f"\n🔧 开始压缩字体...")
    print(f"   输入: {input_font}")
    print(f"   输出: {output_font}")
    
    args = [
        input_font,
        f"--text-file={chars_file}",
        f"--output-file={output_font}",
        "--flavor=woff2",
        "--desubroutinize",
        "--recalc-bounds",
        "--canonical-order",
        "--layout-features=*",
    ]
    
    ttf_output = output_font.replace('.woff2', '.ttf')
    args_ttf = [
        input_font,
        f"--text-file={chars_file}",
        f"--output-file={ttf_output}",
        "--desubroutinize",
        "--recalc-bounds",
    ]
    
    try:
        subset_main(args)
        subset_main(args_ttf)
        
        original_size = os.path.getsize(input_font)
        woff2_size = os.path.getsize(output_font)
        ttf_size = os.path.getsize(ttf_output)
        
        print(f"\n✅ 压缩完成!")
        print(f"   原始大小: {original_size/1024:.2f} KB")
        print(f"   WOFF2 大小: {woff2_size/1024:.2f} KB (压缩率: {woff2_size/original_size*100:.1f}%)")
        print(f"   TTF 大小: {ttf_size/1024:.2f} KB (压缩率: {ttf_size/original_size*100:.1f}%)")
        
        return True
        
    except Exception as e:
        print(f"\n❌ 压缩失败: {e}")
        return False


def main():
    """主函数"""
    HEXO_ROOT = "/www/wwwroot/myblog"
    WORK_DIR = "/www/wwwroot/myblog/font-spider-work"
    INPUT_FONT = os.path.join(WORK_DIR, "fonts", "BailuFeiYun.ttf")
    
    CHARS_FILE = os.path.join(WORK_DIR, "chars-full.txt")
    OUTPUT_WOFF2 = os.path.join(HEXO_ROOT, "source", "fonts", "BailuFeiYun.woff2")
    
    if not os.path.exists(INPUT_FONT):
        print(f"❌ 未找到原始字体: {INPUT_FONT}")
        sys.exit(1)
    
    os.makedirs(os.path.dirname(OUTPUT_WOFF2), exist_ok=True)
    
    chars = generate_char_file(CHARS_FILE, HEXO_ROOT)
    
    if len(chars) < 50:
        print("⚠️  提取字符过少，请检查路径")
        sys.exit(1)
    
    success = subset_font(INPUT_FONT, OUTPUT_WOFF2, CHARS_FILE)
    
    if success:
        print(f"\n🎉 全部完成!")
        print(f"   压缩后的字体已输出到: {os.path.dirname(OUTPUT_WOFF2)}")
    else:
        sys.exit(1)


if __name__ == "__main__":
    main()

工作流程

1. 扫描文章标题 ──┐
2. 扫描页面内容 ──┤
3. 扫描 _data 目录 ─┼──> 收集所有字符 ──> 去重排序 ──> 生成字符文件
4. 扫描配置文件 ──┤
5. 扫描语言文件 ──┘

6. 使用 fonttools 压缩字体
   ├── 输入：原始 TTF 字体
   ├── 根据字符文件裁剪
   └── 输出：WOFF2 + TTF（子集化后）

输出示例

============================================================
Hexo 博客字体压缩工具 - 动态完整版
============================================================

📁 扫描文章标题(仅title): /www/wwwroot/myblog/source/_posts
  扫描了 17 篇文章，提取 143 个独特字符

📁 扫描页面目录(全内容递归):

  📂 charts/
    index.md -> 67 字符
    合计: 1 个文件，67 字符

  📂 agreement/
    index.md -> 433 字符
    合计: 1 个文件，433 字符

  📂 link/
    index.md -> 126 字符
    合计: 1 个文件，126 字符

  📂 essay/
    index.md -> 29 字符
    合计: 1 个文件，29 字符

  📂 categories/
    index.md -> 28 字符
    合计: 1 个文件，28 字符

  📂 _data/
    link.yml -> 201 字符
    bangumis.json -> 231 字符
    creativity.yml -> 75 字符
    essay.yml -> 73 字符
    about.yml -> 232 字符
    合计: 5 个文件，812 字符

  📂 cdn/
    合计: 0 个文件，0 字符

  📂 about/
    index.md -> 34 字符
    合计: 1 个文件，34 字符

  📂 sitemap/
    合计: 0 个文件，0 字符

  📂 tags/
    index.md -> 28 字符
    合计: 1 个文件，28 字符

  📂 privacy/
    index.md -> 379 字符
    合计: 1 个文件，379 字符

📁 扫描数据目录(_data):
    link.yml -> 201 字符
    bangumis.json -> 231 字符
    creativity.yml -> 75 字符
    essay.yml -> 73 字符
    about.yml -> 232 字符
    合计: 5 个文件，812 字符

📁 动态读取配置文件:
  读取站点配置: _config.yml
    -> 360 字符
  读取主题配置: _config.anzhiyu.yml
    -> 526 字符
  读取主题语言文件:
    zh-TW.yml -> 341 字符
    en.yml -> 67 字符
    zh-CN.yml -> 346 字符
    default.yml -> 251 字符
  配置文件共提取: 843 字符

============================================================
✅ 共收集 1180 个独特字符
   - 汉字: 1073 个
   - 英文: 1125 个
   - 数字: 10 个
   - 标点/其他: 45 个
💾 已保存到: /www/wwwroot/myblog/font-spider-work/chars-full.txt

📋 字符预览: 一七万三上下不与专且世业东丢个中丰为主举久么义之乌乎乐也习书乾了予二于云互些交亦产享亮人亿什仅仇今介仍从他付仙代以们件价任份优伙会传伦伴伸但位低住体何作你使來例供依侧侵便保信修個們倒值假偏做停健偿備储...

🔧 开始压缩字体...
   输入: /www/wwwroot/myblog/font-spider-work/fonts/BailuFeiYun.ttf
   输出: /www/wwwroot/myblog/source/fonts/BailuFeiYun.woff2

✅ 压缩完成!
   原始大小: 10806.62 KB
   WOFF2 大小: 712.62 KB (压缩率: 6.6%)
   TTF 大小: 1321.61 KB (压缩率: 12.2%)

🎉 全部完成!
   压缩后的字体已输出到: /www/wwwroot/myblog/source/fonts

文件位置

/www/wwwroot/myblog/
├── source/fonts/           # 输出压缩后的字体
│   ├── BailuFeiYun.woff2
│   └── BailuFeiYun.ttf
├── font-spider-work/       # 工作目录
│   ├── fonts/
│   │   └── BailuFeiYun.ttf  # 原始字体
│   └── chars-full.txt       # 提取的字符列表
└── compress_font.py         # 本脚本

Twikoo私有化部署

Sun, 08 Feb 2026 10:25:41 GMT

前言

对于使用 Hexo 搭建的静态博客而言，一个稳定、轻量的评论系统是连接读者的重要桥梁。Twikoo 作为目前最受欢迎的开源评论方案之一，除了官方提供的云开发版本外，私有化部署能让你获得完全的数据自主权——不再受限于免费额度，无需担心云厂商政策变动，还能通过自定义二级域名和 SSL 证书实现更专业、更稳定的访问体验。
本文将提供一份从零开始的实操指南，手把手教你通过 Docker 完成 Twikoo 的私有化部署。无论你是习惯命令行的开发者，还是偏好图形界面的宝塔用户，都能找到适合自己的部署方式。内容涵盖域名解析、容器配置、反向代理到证书申请的全流程，特别针对 AnZhiYu 等热门 Hexo 主题给出了详细的对接配置。跟随本文操作，你将拥有一个完全属于自己、独立运行的评论服务。

准备：解析二级域名

建议为 Twikoo 单独分配一个二级域名（如 twikoo.yourdomain.com），便于后期维护和管理。

记录类型：A 记录
主机记录：twikoo（或其他你喜欢的二级域名前缀）
记录值：你的服务器 IP 地址

提示：解析生效需要几分钟到几小时不等，可通过 ping twikoo.yourdomain.com 验证是否生效。

拉起Twikoo的容器

方案一：Docker 命令行部署（推荐）

适合熟悉 Linux 命令的开发者，轻量且可控。

1	docker run --name twikoo -e TWIKOO_THROTTLE=1000 -p 8181:8080 -v ${PWD}/data:/app/data -d imaegoo/twikoo

方案二：宝塔面板部署（可视化）

适合不熟悉命令行或已安装宝塔面板的用户。

配置反向代理

直接使用 IP:端口访问既不优雅也不安全。通过 Nginx 反向代理，可以实现：

使用域名访问（如 twikoo.yourdomain.com）
后续支持 HTTPS（SSL 证书）
隐藏真实端口，提高安全性

Nginx 配置示例,在宝塔 “网站” → “反向代理” 中添加：

目标 URL：http://127.0.0.1:8181（即你刚才映射的本地端口）
发送域名：$host

原理：所有访问 twikoo.yourdomain.com 的请求，都会被 Nginx 转发到本地的 8181 端口，由 Twikoo 容器处理。

部署ssl证书

为保证数据传输安全，强烈建议配置 HTTPS。宝塔中操作如下：

在刚才的反向代理站点中，点击 “SSL” 选项卡
选择 “Let’s Encrypt” 免费证书，或上传自己的证书
开启 “强制 HTTPS”

最后再浏览器访问你的Twikoo的域名，以下输出代表Twikoo部署已经完成

开启评论功能

下面可以参考安知鱼主题官方文档开启评论功能

安知鱼主题

到这里Twikoo就部署完成了,最后记得清除缓存和重新生成静态网站

1 2	hexo clean hexo generate

常见问题

Q：为什么选择私有化部署而非云开发？
A：云开发有免费额度限制（如腾讯云每日读取次数限制），私有化部署只要服务器不宕机就永久可用，数据完全自主可控。
Q：容器重启后数据会丢失吗？
A：不会。-v ${PWD}/data:/app/data 已将数据持久化到宿主机，只要 data 文件夹在，重新运行容器数据依然保留。
Q：评论通知如何配置？
A：访问 Twikoo 管理后台（在评论区点击登录，输入管理员密码），在”设置”中配置 SMTP 邮箱或 webhook 推送。

至此，你拥有了一个完全独立的私有化评论系统！

PostgreSQL 16.3基于pg_basebackup实现异步流复制

Thu, 29 Jan 2026 06:45:05 GMT

本文主要介绍基于pg_basebackup实现主从复制（异步流复制）

PostgreSQL安装的方法可以参考这篇文章，PostgreSQL安装

关于基本的配置就不作过多的介绍了，直接开始

MASTER节点

首先在master节点创建一个用于复制的用户rep 设置密码 123456，并授予rolcanlogin权限

1	CREATE ROLE rep WITH REPLICATION LOGIN PASSWORD '123456';

接下来需要配置pg_hba.conf文件，配置完后记得重启PG

由于我们的SLAVE节点是一个DOCKER PG的容器，下面就需要使用pg_basebackup来备份MASTER 节点的数据目录用来启动SLAVE节点，先备份

1	pg_basebackup -D /opt/pg_basebackup/ -h 172.17.0.2 -p 5432 -U rep -Fp -R -X s -P -v

SLAVE节点

接下来在DOCKER的数据目录下创建一个SLAVE的本地映射文件用于启动SLAVE节点

接下来将MASTER节点中pg_basebackup备份的数据COPY到我们准备的本地映射centos9_pg目录下

1	docker cp centos9:/opt/pg_basebackup /var/lib/docker/centos9_pg/

然后启动SLAVE节点即可

1	docker run -itd --name pg.slave.16.3 -e POSTGRES_PASSWORD=123456 -v /var/lib/docker/centos9_pg:/var/lib/postgresql/data 07a4ee949b9e

进入容器，看到从数据目录下多了一个standby.signal文件，这默认是一个空文件，其实是一个标识文件。
是因为上面备份的时候使用了-R参数，所以在同步的数据里，所以会在postgresql.auto.conf里配置上 primary_conninfo信息。

验证主从同步

在MASTER节点上可以看到流复制的监控信息，其中 state = streaming 表示流复制状态正常

1	select * from pg_stat_replication;

下面执行DML语句进行验证（验证的数据在备份之前就可以准备好）

总结

在配置的过程中如果遇到报错一定要去看下错误日志，错误日志中会记录详细信息

Debian 9 (Stretch)仓库无法使用

Tue, 27 Jan 2026 07:26:42 GMT

背景：用镜像拉起的mysql5.6.44的容器，os是Debian GNU/Linux 9 (stretch)

这个错误表明系统仍在使用 Debian 9 (Stretch)，但该版本已于 2022年6月30日结束生命周期（EOL），官方仓库已下线。

解决方案

# 进入容器
docker exec -it  bash

# 导入 Debian 归档密钥
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys AA8E81B4331F7F50 112695A0E562B32A 04E7233B7D453EEC EF0F382A1A7B6500 648ACFD622F3D138 0E98404D386FA1D9

# 修改 apt 源为归档镜像
cat > /etc/apt/sources.list << 'EOF'
deb http://archive.debian.org/debian/ stretch main contrib non-free
deb http://archive.debian.org/debian-security stretch/updates main contrib non-free
EOF

# 清理并更新（忽略有效期）
rm -rf /etc/apt/sources.list.d/mysql.list
apt-get clean
apt-get update -o Acquire::Check-Valid-Until=false -o Acquire::AllowInsecureRepositories=true || true

# 允许未签名安装（应急）
apt-get install -y --allow-unauthenticated

MySQL中常见的慢查询与优化

Fri, 16 Jan 2026 14:41:00 GMT

没有将等值条件列用做组合索引前缀

如果查询语句的谓词条件是范围条件与等值条件，存在组合索引，那么当范围条件列作为索引前缀的时候，等值条件是无法被range optimizer用来生成引擎扫描range减少扫描行数的。

索引列类型和常量类型不一致

当索引列类型和常量类型不一致的时候，可能导致索引无法使用。例如下面的例子，列类型是varchar，而常量类型是Int。在MySQL中varchar类型和int类型比较是会将varchar转换为int类型去比较，这就导致下面语句需要扫描每一行数据将id转换为int类型再做比较。

关联字段类型不一致

对于JOIN操作，如果关联字段类型不一样，比如一个是Int，一个是varchar，由于比较类型是Int，那么varchar字段的关联索引就无法用来生成REF访问，减少扫描行数。

关联字段字符集不一致

对于JOIN操作，如果关联字段的字符集不一致，这也会导致索引无法被有效利用，进而导致扫描大量数据，查询执行慢。

索引列上有表达式计算

当谓词条件中，索引列上有表达式计算的时候，优化器会无法分析抽取range

range optimizer限制

索引的扫描范围分析是由range optimizer处理，一些场景会触发range optimizer的限制。例如in list或者or的条件数太多，在分析扫描范围区间的时候，会消耗大量内存，导致超过range_optimizer_max_mem_size的大小，这类语句EXPLAIN后，在warnings信息中会有提示：

***************************[ 1. row ]***************************
Level   | Warning
Code    | 3170
Message | Memory capacity of 5 bytes for 'range_optimizer_max_mem_size' exceeded. Range optimization was not done for this query.

在 MySQL 中，range_optimizer_max_mem_size 是一个系统变量，用于控制查询优化器在执行查询时可以使用的最大内存大小。这个参数影响查询优化器在处理范围查询（如 BETWEEN、IN 等）时的行为，特别是当这些查询涉及多个表和大量数据时。
参数作用
内存使用：range_optimizer_max_mem_size 指定了查询优化器在处理范围查询时可以使用的最大内存量。如果查询的内存需求超过了这个限制，优化器将尝试使用其他方法来处理查询，例如将范围查询转换为全表扫描。
参数值
默认值：默认值通常为 1MB（1024MB），这意味着查询优化器在处理范围查询时最多可以使用 1MB 的内存。
调整：你可以根据服务器的内存大小和查询的复杂性来调整这个值。增加这个值可以让查询优化器在处理更复杂的范围查询时有更多的内存可用，但也可能增加内存消耗。

Range optimizer跳过index dive

对于索引范围，range optimizer会通过index dive来估算实际扫描行数。由于这会带来实际的数据访问，有一定的代价开销，优化器会限制index dive的场景。对于in list等值条件特别多的场景，当超过eq_range_index_dive_limit的阈值，优化器就不会做index dive，而是基于NDV统计信息去估算扫描行数。如果in list中有倾斜的数据，那么行数估算就会错误。

Index Dive
总结：拿着每个 IN 值或区间边界去索引根页 → 二分定位 → 读取叶子页中的记录条数（rec_per_key）。
例如：
拿着一个 IN 值 → 找到它在索引里的边界页假设表 t 有二级索引 idx(c1)，且当前 SQL 是
SELECT * FROM t WHERE c1 IN (17, 29, 53);
优化器拿到第一个值 17。
从索引根页（root page）开始二分：根页里存的是“子页的最小键值+页号”。
例：根页条目 [10→pageA, 20→pageB, 30→pageC]
17 落在 10~20 之间 → 指向 pageA。
继续二分直到叶子页。pageA 不是叶子，再二分 → 找到叶子页 L17，叶子页里才是真正按顺序排好序的 (c1, row_id) 记录。在叶子页里统计 17 这个键值出现了多少条，叶子页内部也是有序的，二分即可找到第一条 17。顺序往后扫，直到键值 ≠ 17，统计行数 → 得到 rec_per_key(17)=5 条。把这个行数累加到本次 range 的总扫描行数。对 29、53 重复 1~3 步，就能算出。
total_rows = rec_per_key(17) + rec_per_key(29) + rec_per_key(53)。
基于NDV统计信息去估算扫描行数
总结：
“基于 NDV 统计信息去估算扫描行数” 就是“用总行数 ÷ 列的不同值个数，再乘以查询涉及的不同值个数”
NDV
Number of Distinct Values——某一列里 有多少个不同的取值。  例：列 status 只有 'OK','FAIL','RUNNING' 3 种值 ⇒ NDV = 3。
统计信息
MySQL 在执行 ANALYZE TABLE 后，会把
表总行数 rows
该列的 NDV存进 mysql.innodb_index_stats （或 mysql.column_stats 里，8.0 直方图更细）。因此平均每值出现的行数 = rows / NDV。
估算扫描行数
当优化器放弃 “index dive” 时，就直接用上面的平均值乘以 查询里要用到的不同值个数。例子：
如果数据倾斜（例如 c1=1 其实有 8 万行，其余值只有 1 行），
估算 100 行 vs 实际 80 004 行，就会出现 “基于 NDV 的估算失真”。
表 100 万行，列 c1 NDV = 5 万 ⇒ 平均 20 行/值。
SQL：WHERE c1 IN (1,2,3,4,5) （5 个值）。
估算行数 = 20 × 5 = 100 行。

内容整合于数据库内核月报－ 2024 / 12

MySQL查询优化分析 - 常见慢查问题与优化方法

mysql"黑名单"

Tue, 13 Jan 2026 09:08:00 GMT

目的：使用iptables禁止121.43.122.130客户端连接140.143.94.243机器上部署的mysql

部署MySQL的机器	客户端
140.143.94.243	121.43.122.130

安装 iptables-services（若没装）

1	yum install -y iptables-services

让 systemd 接管iptables

1	systemctl start iptables

在部署MySQL机器上的filter表INPUT链里加一条DROP规则

1	iptables -I INPUT -s 121.43.122.130 -p tcp --dport 3306 -j DROP

查看规则是否已插入

1	iptables -nvL

验证

这种情况下端口不通

删除规则

1	iptables -D INPUT -s 121.43.122.130 -p tcp --dport 3306 -j DROP

针对这类iptables禁用后使用wireshark分析抓包情况，可以看到tcp一直再重传

MySQL中的Got an error reading communication packet

Sat, 10 Jan 2026 14:54:56 GMT

我们经常在MySQL的error log中可以看到这样的[Note]，从官网的介绍来说，导致下述这种情况出现的原因，有下述几种

https://dev.mysql.com/doc/refman/8.0/en/communication-errors.html

另外我们要清楚，Got an error reading communication packets：是客户端异常关闭之后DB才会被动打印的日志，不是DB主动关闭的。所以首要排查方向应该是应用侧，非db侧。如果是客户端超过wait_timeout不活动被DB主动关闭的话，应该打印的日志是：Got timeout reading communication packets

场景分析

客户端使用mycli和mysql分别去连接

mycli

可以看到使用mycli连接后Aborted_clients 增加，并且错误日志中出现

[Note] [MY-010914] [Server] Aborted connection 9 to db: ‘unconnected’ user: ‘root’ host: ‘localhost’ (Got an error reading communication packets)

mysql

而使用mysql连接后则没有这个问题

针对mycli连接时出现的这个情况进行了抓包分析，可以看到38行有个[FIN,ACK]的Flags，查看传输层的信息发现是客户端主动关闭了连接，This frame initiates the connection closing。查看39行，可以看到应用层返回了

Error message: Got an error reading communication packets，并且在40行可以看到RST的Flags，这里可能和mycli的客户端行为有关

而使用mysql连接时查看返回的抓包情况并没有RST的Flags

MySQL【bug】- spatial key

Fri, 09 Jan 2026 11:38:47 GMT

【bug1】

MySQL建Spatial索引的前提条件是列定义NOT NULL，而当location列中有**’GEOMETRYCOLLECTION EMPTY ‘的值时，这里‘GEOMETRYCOLLECTION EMPTY’**变相绕过了这个限制，会导致报错。

插入空集合 GEOMETRYCOLLECTION EMPTY，空集合占一行空间，语义上“我知道这里该有几何，但当前没有数据”。

与 NULL 的区别

场景	存储值	ST_IsEmpty	ST_AsText
NULL	无	NULL	NULL
GEOMETRYCOLLECTION EMPTY	有	1	GEOMETRYCOLLECTION EMPTY

重建表也无法进行修复

CREATE TABLE `spatial_table` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `location` geometry NOT NULL SRID 4326,
  `number` varchar(20) NOT NULL DEFAULT '7425346',
  PRIMARY KEY (`id`),
  UNIQUE KEY `number` (`number`),
  SPATIAL KEY `location_index` (`location`)
);

INSERT INTO spatial_table (id, name, location, number)
VALUES
(1, 'Place A', ST_GeomFromText('POINT(1 1)', 4326), '7425341'),
(2, 'Place B', ST_GeomFromText('LINESTRING(1 1,2 2,3 3)', 4326), '7425342'),
(3, 'Place C', ST_GeomFromText('POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7,5 5))', 4326), '7425343'),
(4, 'Place D', ST_GeomFromText('MULTIPOINT((0 0),(20 20),(60 60))', 4326), '7425344'),
(5, 'Place E', ST_GeomFromText('GEOMETRYCOLLECTION(POINT(10 10),POINT(30 30),LINESTRING(15 15,20 20))', 4326), '7425345'),
(6, 'Place F', ST_GeomFromText('GEOMETRYCOLLECTION(POINT(10 10),POINT(30 30),LINESTRING(15 15,20 20))', 4326), '7425348'),
(7, 'Beijing', ST_GeomFromText('POINT(39.9042 116.4074)', 4326), '7425347'),
(8, '', ST_GeomFromText('GEOMETRYCOLLECTION EMPTY', 4326), '7425346');  

SELECT id,name,st_astext(location),number From spatial_table;

解决方法：删除这些行并重建表

【bug2】

先对含** SPATIAL KEY** 的表做过 ALTER TABLE → R-tree 根页指针错乱，后续 UPDATE/DELETE走空间索引时找不到记录 → 报** Record in index … not found**。在MySQL Server 5.7.49、8.0.41、8.4.4和9.2.0版本中修复。

官方文档：https://bugs.mysql.com/bug.php?id=93728

CREATE TABLE tab (
  c1 INT NOT NULL PRIMARY KEY,
  c2 POINT NOT NULL SRID 4326,
  c3 LINESTRING NOT NULL SRID 4326,
  c4 POLYGON NOT NULL SRID 4326,
  c5 GEOMETRY NOT NULL SRID 4326,
  SPATIAL KEY idx2 (c2),
  SPATIAL KEY idx3 (c3),
  SPATIAL KEY idx4 (c4),
  SPATIAL KEY idx5 (c5)
) ENGINE = InnoDB;

INSERT INTO tab(c1,c2,c3,c4,c5) VALUES
(1,
 ST_GeomFromText('POINT(10 10)', 4326),
 ST_GeomFromText('LINESTRING(5 5,20 20,30 30)', 4326),
 ST_GeomFromText('POLYGON((30 30,40 40,50 50,30 50,30 40,30 30))', 4326),
 ST_GeomFromText('POLYGON((30 30,40 40,50 50,30 50,30 40,30 30))', 4326));

INSERT INTO tab(c1,c2,c3,c4,c5) VALUES
(2,
 ST_GeomFromText('POINT(20 20)', 4326),
 ST_GeomFromText('LINESTRING(20 20,30 30,40 40)', 4326),
 ST_GeomFromText('POLYGON((40 50,40 70,50 100,70 100,80 80,70 50,40 50))', 4326),
 ST_GeomFromText('POLYGON((40 50,40 70,50 100,70 100,80 80,70 50,40 50))', 4326));

ALTER TABLE tab
  ADD COLUMN new_uniq_col INT NOT NULL AUTO_INCREMENT FIRST,
  ADD UNIQUE INDEX uniq_idx(new_uniq_col),
  DROP PRIMARY KEY;

DELETE From tab;

解决方法：

升级版本
重建表再重新导入数据

py_innodb_page_info.py表空间分析

Sun, 04 Jan 2026 09:07:59 GMT

介绍

由《MySQL技术内幕 InnoDB存储引擎》一书的作者姜承尧开发的 py_innodb_page_info.py 是一款功能强大的工具，旨在深入分析MySQL表空间中的页面类型及其详细信息。该工具采用Python编写，由三个文件组成：py_innodb_page_info.py、mylib.py 和 include.py。为了确保工具的正常运行，这三个文件需要放置在同一个目录下。

值得注意的是，该工具需要在Python 2的环境中运行。如果在Python 3环境下使用，可能会遇到兼容性问题，导致运行出错。此外，py_innodb_page_info.py 工具专门设计用于解析MySQL 5.7版本的.ibd文件。对于MySQL 8.0及更高版本的.ibd文件，该工具可能无法正确解析。

include.py

#include.py
#encoding=utf-8
INNODB_PAGE_SIZE = 1024 * 16 # InnoDB Page 16K

# Start of the data on the page
FIL_PAGE_DATA = 38

FIL_PAGE_OFFSET = 4 # page offset inside space
FIL_PAGE_TYPE = 24 # File page type

# Types of an undo log segment */
TRX_UNDO_INSERT = 1
TRX_UNDO_UPDATE = 2

# On a page of any file segment, data may be put starting from this offset
FSEG_PAGE_DATA = FIL_PAGE_DATA

# The offset of the undo log page header on pages of the undo log
TRX_UNDO_PAGE_HDR = FSEG_PAGE_DATA

PAGE_LEVEL = 26 #level of the node in an index tree; the leaf level is the level 0 */

innodb_page_type = {
        '0000':u'Freshly Allocated Page',
        '0002':u'Undo Log Page',
        '0003':u'File Segment inode',
        '0004':u'Insert Buffer Free List',
        '0005':u'Insert Buffer Bitmap',
        '0006':u'System Page',
        '0007':u'Transaction system Page',
        '0008':u'File Space Header',
    '0009':u'Extend Description Page',
    '000a':u'Uncompressed BLOB Page',
    '000b':u'1st compressed BLOB Page',
    '000c':u'Subsequent compressed BLOB Page',
    '45bf':u'B-tree Node'
}
innodb_page_direction = {
        '0000': 'Unknown(0x0000)',
    '0001': 'Page Left',
    '0002': 'Page Right',
    '0003': 'Page Same Rec',
    '0004': 'Page Same Page',
    '0005': 'Page No Direction',
    'ffff': 'Unkown2(0xffff)'
}

mylib.py

#encoding=utf-8
import os
import include
from include import *

VARIABLE_FIELD_COUNT = 1
NULL_FIELD_COUNT = 0

class myargv(object):
    def __init__(self, argv):
        self.argv = argv
        self.parms = {}
        self.tablespace = ''

    # 解析输入参数
    def parse_cmdline(self):
        argv = self.argv
        if len(argv) == 1:
            print 'Usage: python py_innodb_page_info.py [OPTIONS] tablespace_file'
            print 'For more options, use python py_innodb_page_info.py -h'
            return 0
        while argv:
            if argv[0][0] == '-':
                if argv[0][1] == 'h':
                    self.parms[argv[0]] = ''
                    argv = argv[1:]
                    break
                if argv[0][1] == 'v':
                    self.parms[argv[0]] = ''
                    argv = argv[1:]
                else:
                    self.parms[argv[0]] = argv[1]
                    argv = argv[2:]
            else:
                self.tablespace = argv[0]
                argv = argv[1:]
        if self.parms.has_key('-h'):
            print 'Get InnoDB Page Info'
            print 'Usage: python py_innodb_page_info.py [OPTIONS] tablespace_file\n'
            print 'The following options may be given as the first argument:'
            print '-h   help '
            print '-o output put the result to file'
            print '-t number thread to anayle the tablespace file'
            print '-v   verbose mode'
            return 0
        return 1

def mach_read_from_n(page,start_offset,length):
    ret = page[start_offset:start_offset+length]
    return ret.encode('hex')

# main方法
def get_innodb_page_type(myargv):
        # 读取 .ibd 文件，存入 f
    f=file(myargv.tablespace,'rb')
    # INNODB_PAGE_SIZE=16KB，f 一定是16KB的整数倍，一页大小是16KB
    # 使用 f 的字节总数除以 16KB，得到的 fsize 表示页数
    fsize = os.path.getsize(f.name)/INNODB_PAGE_SIZE
    ret = {}
    # 枚举每一页
    for i in range(fsize):
        # 读取16KB数据，存入page，是第i的数据
        # page 是二进制文件
        page = f.read(INNODB_PAGE_SIZE)
        # page_offset 是 page[4， 8) 字符所表示的数据
        page_offset = mach_read_from_n(page,FIL_PAGE_OFFSET,4)
        # page_type 是 page[24, 26) 字符所表示的数据
        page_type = mach_read_from_n(page,FIL_PAGE_TYPE,2)
        # 如果加了参数 -v，表示输出详细数据
        if myargv.parms.has_key('-v'):
                # page_type 为 45bf，表示 B-tree Node，输出它的信息
            if page_type == '45bf':
                # page_level 是 page[64, 66) 字符所表示的数据
                page_level = mach_read_from_n(page,FIL_PAGE_DATA+PAGE_LEVEL,2)
                print "page offset %s, page type <%s>, page level <%s>"%(page_offset,innodb_page_type[page_type],page_level)
            # page_type 对应 include.py 中的 innodb_page_type，输出它的信息
            else:
                print "page offset %s, page type <%s>"%(page_offset,innodb_page_type[page_type])
        # 统计数据
        if not ret.has_key(page_type):
            ret[page_type] = 1
        else:
            ret[page_type] = ret[page_type] + 1
    # 输出fsize，表示有多少页
    print "Total number of page: %d:"%fsize
    # 输出统计数据
    for type in ret:
        print "%s: %s"%(innodb_page_type[type],ret[type])

py_innodb_page_info.py

#! /usr/bin/env python
#encoding=utf-8
import mylib
from sys import argv
from mylib import myargv

# main函数
if __name__ == '__main__':
        myargv = myargv(argv)
        if myargv.parse_cmdline() == 0:
                pass
        else:
                # 执行main方法
                mylib.get_innodb_page_type(myargv)

示例

先创建个example_table空表，看下example_table.ibd，可以看到总共分配了11page（Total number of page: 11），但是为啥空闲的只有6page（B-tree Node: 6），这里就不得不提到之前说到的预留空间了

CREATE TABLE example_table(
    id INT AUTO_INCREMENT,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    email VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    status ENUM('active', 'inactive') DEFAULT 'active',
    PRIMARY KEY (id),
    INDEX idx_last_name (last_name),
    FULLTEXT INDEX ftx_first_name (first_name),
    INDEX idx_status (status),
    INDEX idx_created_at (created_at),
    INDEX idx_first_name_last_name (first_name, last_name)
);

1	python2 py_innodb_page_info.py -v demo1/example_table.ibd

page offset 00000000, page type 
page offset 00000001, page type 
page offset 00000002, page type 
page offset 00000003, page type , page level <0000>  //数据页，0001表示根层，0000表示叶子层
page offset 00000004, page type , page level <0000>
page offset 00000005, page type , page level <0000>
page offset 00000006, page type , page level <0000>
page offset 00000007, page type , page level <0000>
page offset 00000008, page type , page level <0000>
page offset 00000000, page type 
page offset 00000000, page type 
Total number of page: 11://总共分配的页数
Freshly Allocated Page: 2//可用的数据页
Insert Buffer Bitmap: 1//插入缓冲页
File Space Header: 1//文件空间头
B-tree Node: 6//数据页
File Segment inode: 1//文件端inonde

然后再使用存储过程插入1W行数据，再分析example_table.ibd

DELIMITER $$

CREATE PROCEDURE InsertExampleData()
BEGIN
    DECLARE i INT DEFAULT 1;
    DECLARE maxEmail INT DEFAULT 1000;
    DECLARE firstName VARCHAR(50);
    DECLARE lastName VARCHAR(50);
    DECLARE email VARCHAR(100);
    DECLARE status ENUM('active', 'inactive');
    DECLARE timestamp DATETIME;

    WHILE i <= 10000 DO
        SET firstName = CONCAT('Name', LPAD(i, 5, '0'));
        SET lastName = CONCAT('Surname', LPAD(i, 5, '0'));
        SET email = CONCAT(firstName, '_', lastName, '_', i, '@example.com');
        SET status = IF(i % 2 = 0, 'active', 'inactive');
        SET timestamp = DATE_ADD(NOW(), INTERVAL FLOOR(RAND() * 365) DAY);

        INSERT INTO example_table (first_name, last_name, email, created_at, status)
        VALUES (firstName, lastName, email, timestamp, status);

        SET i = i + 1;
    END WHILE;
END$$

DELIMITER ;

1	CALL InsertExampleData();

page offset 00000000, page type 
page offset 00000001, page type 
page offset 00000002, page type 
page offset 00000003, page type , page level <0001>
page offset 00000004, page type , page level <0001>
page offset 00000005, page type , page level <0001>
page offset 00000006, page type , page level <0001>
page offset 00000007, page type , page level <0001>
page offset 00000008, page type , page level <0001>
page offset 00000009, page type , page level <0000>
page offset 0000000a, page type , page level <0000>
page offset 0000000b, page type , page level <0000>
page offset 0000000c, page type , page level <0000>
page offset 0000000d, page type , page level <0000>
page offset 0000000e, page type , page level <0000>
page offset 0000000f, page type , page level <0000>
page offset 00000010, page type , page level <0000>

....


page offset 00000000, page type 
page offset 00000000, page type 
page offset 00000000, page type 
page offset 00000000, page type 
page offset 00000000, page type 
Total number of page: 640://总共分配的页数
Freshly Allocated Page: 493//可用的数据页
Insert Buffer Bitmap: 1//插入缓冲页
File Space Header: 1//文件空间头
B-tree Node: 144//数据页
File Segment inode: 1//文件端inonde

这时可以看到总共分配640页（Total number of page）即10240kb，使用了144页（B-tree Node）即2304kb，可用的数据页493页（Freshly Allocated Page）即7888kb

同时去看information_schema.tables中example_table的信息，可以看到DATA_LENGTH+INDEX_LENGTH=1589248byte+1261568byte=2850816byte=2784kb，DATA_FREE=4194304byte=4096kb，

DATA_LENGTH+INDEX_LENGTH+DATA_FREE=6880kb 10240-6880=3360kb

Insert Buffer Bitmap+File Space Header+File Segment inode=48kb

那这里为什么6880kb（ DATA_LENGTH+INDEX_LENGTH+DATA_FREE）要远远小于10240kb（Total number of page），这是除了之前提到的预留空间还有碎片率吗？

ok，我们带着这个问题去分析。

1	select * from information_schema.tables where table_schema='demo1' and table_name='example_table'\G

这里我们计算下空间碎片率Space Debris Rate=(70451204194304)×100≈59.53%

SELECT  
  table_name,
  table_rows,
  ROUND(data_length / (1024 * 1024 * 1024), 2) AS data_length_gb,
  ROUND(index_length / (1024 * 1024 * 1024), 2) AS index_length_gb,
  data_free,
  CASE 
    WHEN (data_length + index_length + data_free) > 0 THEN 
      ROUND(data_free / (data_length + index_length + data_free) * 100, 2) 
    ELSE 
      0 
  END AS space_debris_rate
FROM information_schema.tables 
WHERE table_schema = 'demo1' AND table_name = 'example_table';

这里我们将example_table的数据全部删除然后analyze table example_table; ，再查看information_schema.tables的统计信息，然后执行optimize table demo1.example_table; ，再去分析。最后可以看到DATA_LENGTH+INDEX_LENGTH+DATA_FREE=16384+ 81920+0=96kb=6page=B-tree Node

Error response from daemon: driver failed programming external connectivity on endpoint

Wed, 31 Dec 2025 03:30:19 GMT

error log

从报错日志来看是iptables的转发规则有问题

docker logs centos9查看容器日志，没看出什么异常

CSDN文章参考

看了上述文章之后，想起来昨天在配置k8s的时候关闭了firewalld。嗯，然后把docker服务重启，最后在启动容器果然没有报错了

PostgreSQL YUM安装

Fri, 12 Dec 2025 03:34:56 GMT

配置环境

Linux	PostgreSQL	Docker
centos7	15	24.0.7

docker中的centos7中安装

选择对应的版本然后在容器中的centos7中执行下面命令

但是启动容器的时候需要注意

开启端口映射
开启特权模式
启动init进程

1	docker run -itd --name centos-postgresql -p 5433:5432 --privileged=true centos:centos7 /usr/sbin/init

启动然后进入后先安装ibzstd.so.1依赖

1 2	yum install epel-release.noarch -y yum install libzstd.x86_64 -y

安装PosqtgreSQL

官网安装教程：https://www.postgresql.org/download/linux/redhat/

安装完依赖后就可以按下面的顺序执行命令

yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm
yum install -y postgresql15-server
/usr/pgsql-15/bin/postgresql-15-setup initdb
systemctl enable postgresql-15
systemctl start postgresql-15

执行完成后就可以切换用户登陆postgresql了

#切换用户
su - postgres
#登陆数据库
psql

接下来配置数据库访问控制文件，主要是配置postgresql.conf 和 pg_hba.conf 个。

postgresql.conf 针对实例的配置
pg_hba.conf 针对数据库访问的控制

切换到/var/lib/pgsql/15/data目录下

注意：这里/var/lib/pgsql/15/data的15要根据自己安装的版本来确定

配置postgresql.conf

1	vim postgresql.conf

找到”#port”和”#listener_address”这两个参数，这两个参数是相邻的，将两行行首的”#”删除。
将”listen_addressee=’localhost’”改为当前服务器的IP，如果改为

“listen_addressee=’*’”，将监听整个网络。
默认的监听端口是5432，可以自行指定另外一个端口号。
max_connections是客户端最大的连接数，缺省值100有点少，特别是业务系统，可以调整成1000或者更高。

配置pg_hba.conf

1	vim pg_hba.conf

将红框设置为 10.10.100.0/24，意思是10.10.100网段的IP 连接此服务器上的PostgreSQL. 如果想允许所有IP都可以连接此服务器，则可以配置成0.0.0.0/0，但这样是不安全的，可以把trust改为md5，表示需要密码访问，算是提供一个最低级的安全防护。

配置完这俩个文件后就可以重启数据库了

1	systemctl restart postgresql-15

记得关闭防火墙

1	systemctl stop firewalld

测试连接

docker中直接安装

拉取postgresql镜像后直接启动容器

#拉去镜像
docker search postgres
#启动容器
docker run -itd --name postgresql -e POSTGRES_PASSWORD=数据库密码 -p 5555:5432 postgres

测试连接成功

注意事项：

两个centos7中的防火墙记得都要放行端口或者关闭
postgresql.conf 和 pg_hba.conf文件记得配置

从Miniflux 到 NextFlux：一步升级，拥抱现代化阅读体验

Thu, 11 Dec 2025 03:51:56 GMT

前段时间我部署了Miniflux，这是一款功能强大的极简主义RSS订阅器，它支持多平台同步、文章过滤和离线阅读等实用功能，完全满足了我的信息聚合需求；不过它的界面设计确实过于朴素，采用了最基础的列表布局和单调的配色方案，在这个视觉至上的时代里，这种毫不修饰的极简风格可能会让许多用户在初次接触时就失去耐心，随手划走转而选择那些界面更炫目、交互更花哨的阅读应用。

因此，为了弥补 Miniflux 在视觉和交互体验上的不足，我这次专门挑选了一款高颜值的第三方客户端 Nextflux。它不仅继承了 Miniflux 强大的 RSS 订阅和内容聚合功能，更通过现代化的界面设计、流畅的动画效果和直观的操作逻辑，大幅提升了用户的使用愉悦感。例如，Nextflux 支持暗黑模式与自定义主题，卡片式布局让信息浏览更加清晰高效，同时保留了 Miniflux 原有的离线阅读与全文抓取等核心能力，真正实现了功能与美感的平衡。

Nextflux 是一个基于现代化技术栈精心打造的 RSS 阅读器客户端，它专门为开源的Miniflux后端服务设计，完美融合了便捷性和功能性。该客户端采用前沿的React框架进行用户界面开发，并结合Vite这一高效构建工具，不仅确保了极速的热重载和流畅的开发体验，还优化了生产环境的打包性能，为用户提供轻量、响应迅速且高度可定制的阅读界面。无论是订阅源的智能管理、文章的分类筛选，还是跨设备的同步阅读，Nextflux都致力于提升信息获取的效率和舒适度，让用户能够专注于内容本身，而无需为技术细节分心。

Nextflux与Miniflux类似，同样采用轻量级的容器化部署方式，能够通过Docker或Podman等工具快速搭建和运行，极大简化了安装与维护流程；这种部署模式不仅确保了环境的一致性，还支持灵活扩展与版本管理，特别适合个人或小团队在云服务器、本地主机乃至树莓派等设备上高效部署，同时保持了低资源占用和高稳定性的特点。

由于之前部署了Miniflux下面就直接部署Nextflux了，当然再结尾也会附上Miniflux+Nextflux+DB的完整yml文件

使用下述命令直接拉起nextflux的容器

1	docker run -itd --restart unless-stopped --name nextflux -p 8121:3000 electh/nextflux:latest

这里需要注意下Nextflux容器的端口

拉起容器后，直接通过宿主机的IP地址加上映射的8121端口（如http://192.168.1.100:8121）在浏览器中访问即可；若页面加载失败，通常是由于端口映射错误导致的，此时需要检查容器日志确认实际监听的端口号，既可以通过命令行方式查看（如执行docker logs 容器ID命令获取详细日志），也可以在宝塔面板的”容器管理”界面中直观地查看运行日志，此外还需确认服务器防火墙是否放行了该端口，这些都是导致访问失败的常见原因。

到这里基本上就可以看到Nextflux的登录界面了，我们可以看到这里除了用户名和密码外，还有个服务地址，这个服务地址就是Miniflux的访问地址，但是有几点需要注意

如果你浏览器访问Nextflux的地址使用的是ip，那么服务地址这里就需要使用 http://ip:port，
如果你浏览器访问Nextflux的地址使用的域名，那么服务地址这里必须使用 https://域名

下面，我们来详细分析使用IP地址访问时出现”Failed to fetch”错误的问题：当按照本文的部署方式部署Nextflux和Miniflux后，即使使用同一IP地址访问也会遇到跨域问题，这是因为浏览器严格执行同源策略，会对比前端页面来源和API请求地址的协议、域名和端口是否完全一致。具体来说，假设你通过http://140.143.94.243:8121访问Nextflux前端界面，而该前端尝试向http://140.143.94.243:80的Miniflux后端发起API请求时，虽然IP地址相同，但由于端口号不同（8121 vs 80），浏览器会判定为跨域请求，此时浏览器会先发送一个OPTIONS预检请求来检查服务器是否允许跨域访问；如果Miniflux后端没有正确配置CORS头部信息，特别是缺少关键的Access-Control-Allow-Origin响应头，或者该头部的值不包含前端来源地址，浏览器就会直接拦截后续的实际请求，导致前端控制台报出”Failed to fetch”错误。要解决这个问题，最直接的方法是在启动Miniflux容器时添加两个必要的环境变量，这些配置会让Miniflux正确处理跨域请求并返回适当的CORS头部，修改后需要重启Miniflux容器使配置生效。

1
2
3

environment:
  - CORS_ORIGINS=http://140.143.94.243:8121
  - CORS_ALLOW_HEADERS=*

这里我建议直接使用宝塔面板的可视化操作界面进行操作，这样不仅能显著提高操作容错率，还能避免因手动输入命令导致的潜在错误；关于yml配置文件，我们可以直接复用之前部署Miniflux时使用的模板文件，只需在数据库配置部分额外添加这两个关键环境变量即可，完成这些修改后，直接保存配置文件即可生效，此时我们再次通过IP地址访问服务并进行登录操作，整个过程就会变得非常顺畅，不会再出现之前遇到的连接或认证问题，这种方案既保留了原有配置的稳定性，又通过最小改动实现了新功能的支持。

services:
  miniflux:
    image: miniflux/miniflux:latest
    ports:
      - "8383:8080"
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgres://miniflux:admin@123@db/miniflux?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=admin@123
  - CORS_ORIGINS=http://140.143.94.243:8121   #填写你的实际ip和port
      - CORS_ALLOW_HEADERS=*
    healthcheck:
      test: ["CMD", "/usr/bin/miniflux", "-healthcheck", "auto"]

  db:
    image: postgres:17-alpine
    environment:
      - POSTGRES_USER=miniflux
      - POSTGRES_PASSWORD=admin@123
      - POSTGRES_DB=miniflux
    volumes:
      - miniflux-db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "miniflux"]
      interval: 10s
      start_period: 30s

volumes:
  miniflux-db:

最后，我们重点讲解使用域名访问和登录时需要注意的技术细节，特别是关于HTTPS协议和URL格式规范的问题。当使用HTTPS协议访问Miniflux服务时，必须确保后端服务地址同样采用HTTPS协议，否则浏览器会因混合内容安全策略而阻止请求。这里特别要强调的是URL尾斜杠的处理问题：如果你在服务地址栏输入的是类似”https://miniflux.mingliang.net.cn/这样带有尾斜杠的地址，而前端JavaScript代码在拼接API路径时又没有正确处理这个斜杠，就会产生https://miniflux.mingliang.net.cn**//**api/me这样的双斜杠路径。这种URL格式错误虽然看起来很小，但会导致严重的后果：大多数现代Web服务器（如Nginx、Apache）会将其视为无效路径，返回404 Not Found错误；而浏览器端的fetch API则会抛出”Failed to fetch”的通用错误，给调试带来困难。这个问题在单页应用(SPA)开发中尤为常见，正确的做法应该是在配置文件中统一规范基础URL格式，或者在JavaScript代码中加入路径标准化处理逻辑，确保API请求的URL始终保持正确的单斜杠格式。

如果你之前没有部署过Miniflux这个轻量级RSS阅读器的话，使用docker-compose进行一体化安装是最便捷的方式，首先你需要创建一个名为docker-compose.yml的配置文件，将以下内容完整复制进去，其中包括了Miniflux服务及其必需的PostgreSQL数据库配置，确保网络设置和端口映射（通常Miniflux默认使用8080端口）正确无误后，在当前目录下执行docker-compose up -d命令即可启动容器编排，系统会自动拉取最新镜像并完成所有依赖服务的部署，整个过程无需手动干预，非常适合快速搭建个人阅读服务。

version: '3'

services:
  miniflux:
    image: miniflux/miniflux:latest
    container_name: miniflux-server
    restart: unless-stopped
    ports:
      - "8120:8080"
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgres://miniflux:secret@db/miniflux?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=test123
  
  db:
    image: postgres:17-alpine
    container_name: miniflux-db
    restart: unless-stopped
    environment:
      - POSTGRES_USER=miniflux
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=miniflux
    volumes:
      - ./data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "miniflux"]
      interval: 10s
      start_period: 30s

  nextflux:
    image: electh/nextflux:latest
    container_name: miniflux-nextflux
    restart: unless-stopped
    ports:
      - "8121:80"

1	docker-compose up -d

这种联合部署的方式Eucalyptus之前确实没有尝试过，主要参考了AWS和Azure的混合云架构设计思路，并结合了《云计算架构设计模式》一书中提到的服务网格集成方案，如果有任何配置问题或性能优化建议，欢迎各位技术同行在评论区留言讨论。另外Eucalyptus部署的Nextflux测试环境已经稳定运行两周，访问地址是https://nextflux.mingliang.net.cn，该平台集成了实时数据流处理和可视化分析功能，各位朋友如果需要测试体验的话可以留言说明具体，Eucalyptus会根据使用场景为大家提供免费的测试账号。

使用pgcli实现PostgreSQL命令自动补全功能

Thu, 11 Dec 2025 03:49:13 GMT

安装和配置python-3.9.0可以参考下述文章

使用mycli实现MySQL命令自动补全功能（Python-3.9.0）

下面我们直接来安装pgcli

1	pip install pgcli

安装号后使用pgcli登陆的时候会发现有个报错

这里我们参考提示移动下这个文件的位置就好了

1	mv /root/.pgclirc /root/.config/pgcli/

然后登陆到postgres用户来登陆我们的postgresql

#登陆postgres用户
su - postgres
#登陆postgresql数据库
pgcli

MySQL性能分析工具(pperf+Flame Graphs)

Thu, 04 Dec 2025 06:21:06 GMT

本文将介绍如何使用perf和Flame Graphs工具对MySQL进行性能分析，这两个工具能够以图形化的形式展现MySQL中的哪些函数被调用以及调用次数，对于MySQL性能分析和优化有较大的作用。

perf 用来采集性能数据，Flame Graphs 使用perf采集的数据进行图形化展示

安装perf

1	yum install -y perf

使用Linux perf工具进行系统级性能数据采集

# 针对特定进程进行性能分析
perf record -F 99 -p  -g -- sleep 60
#任务时钟
perf record -a -g -e task-clock -p 3601 -- sleep 60

数据采集完成后，通常会生成一个二进制数据文件perf.data，通过下面的命令将采集的二进制数据进行加工，转换成易于阅读的文本文件，

1	perf script > perf.script

安装FlameGraph

1	git clone https://github.com/brendangregg/FlameGraph

将perf.script文件作为输入，通过Flame Graphs工具，生成svg格式的性能图形

1	../FlameGraph/stackcollapse-perf.pl perf.script \| ../FlameGraph/flamegraph.pl > flamegraph.svg

现在，可以在网络浏览器中打开 flamegraph.svg

使用perf+Flame Graphs方式，能够从更深层的函数调用上，以图形化的方式看到MySQL是如何执行的，以及具体某个函数执行了多少次，能够更好地看到隐藏在进程之后的具体操作，相对于文本，图形化的展示，更容易被人阅读，也更容易发现性能瓶颈以及相应的优化方向。

MiniFlux安全升级

Sat, 08 Nov 2025 08:39:45 GMT

在信息过载的时代，RSS 依旧是高效获取优质内容的“净土”。Miniflux 以轻量、简洁、开源的姿态，成为许多技术人自托管 RSS 的首选。然而，只在内网 IP 下阅读未免辜负了它的优雅；给 Miniflux 配一个专属的二级域名，再披上 HTTPS 的“安全外衣”，不仅能让阅读随时随地、安全无虞，更是对自己数字领地的一次仪式感升级。接下来的篇幅，我们一起把localhost:8383变成https://miniflux.mingliang.net.cn/，让每一次订阅与更新都拥有值得收藏的新地址。

首先本篇文章中使用的是二级域名，大伙都知道域名是需要进行备案的，“而二级域名需不需要备案”取决于它的一级域名是否已经取得备案号，以及二者是否使用同一家云接入商，大致分为以下几种情况。

一级域名已备案，且二级域名与一级域名在同一接入商 → 二级域名无需单独备案。
一级域名已备案，但二级域名要换到另一家国内接入商 → 先做一次“新增接入备案”，等通过后才能解析到新 IP。
一级域名没有任何备案号 → 必须先把一级域名提交首次备案，二级域名才能在中国大陆正常访问。
政府/事业单位的.gov.cn等后缀二级域名 → 无论一级域名是否已备案，都要单独备案。

只要网站服务器放在中国大陆，访问者能直接通过二级域名打开网页，就适用上述规则；如果服务器在境外，理论上不受中国备案系统约束，但国内 DNS/CDN 厂商通常仍会提示“一级域名需已备案”才能开启加速或防护功能。

备案就不过多赘述了，如果不清楚的，可以参考下这篇文章：网站ICP备案和公安备案教程，下面直接进行二级域名解析教程

这里以阿里云为例，在一级域名中添加一条解析记录时，首先需要登录阿里云控制台并进入域名解析管理页面，在DNS解析设置中选择”添加记录”选项，这里的记录类型可以根据实际需求选择A类型（用于将域名指向IPv4地址），主机记录则填写你的二级域名前缀（如”www”或”blog”等），记录值需要填写对应服务器的公网IP地址（对于A记录），TTL（生存时间）通常保持默认值即可，但也可以根据业务需求进行调整，设置完成后点击确认即可完成解析记录的添加，一般情况下解析会在10分钟内生效，但受各地DNS缓存影响，全球完全生效可能需要24-48小时。

接下来进行Nginx反向代理的配置，全程使用宝塔面板的可视化界面操作，首先登录宝塔面板后，在左侧导航栏找到”网站”模块并点击进入，在菜单中选择”反向代理”选项，这时会显示当前站点的反向代理配置页面，然后点击左上角的”添加反向代理”按钮

在域名配置栏中，需要填写之前在域名控制台已解析完成的二级域名（如”test.example.com”），目标URL地址则应填写本地服务器地址http://127.0.0.1并加上对应的服务端口号（例如:8383表示该服务运行在8383端口），发送域名host保持默认设置即可（通常为自动填充的当前域名），备注栏可根据实际需求填写该条记录的相关说明（如”测试环境API服务”或”开发调试用”等描述性内容），确认所有信息无误后点击保存按钮完成配置。

最后为刚才配置的反向代理服务开启HTTPS加密连接，首先在控制面板中找到并点击刚才添加的反向代理条目右侧的设置按钮，在弹出的菜单中选择”SSL”选项，然后选择Let’sL Encrypt免费证书服务，系统会自动验证域名所有权并生成证书请求，验证通过后点击”申请证书”按钮，等待证书签发完成后，务必记得点击”部署”按钮将证书应用到当前反向代理配置中，这样就能为网站流量提供端到端的加密保护，有效防止数据在传输过程中被窃听或篡改，同时还能提升网站在搜索引擎中的排名。

到这里Miniflux 安全升级的全部部署工作已经圆满完成，我们不仅为Eucalyptus的个人RSS阅读器Miniflux绑定了专属域名miniflux.mingliang.net.cn，还成功配置了HTTPS加密协议，确保数据传输的安全性，现在您可以通过https://miniflux.mingliang.net.cn/这个安全链接访问这个清爽简洁的RSS聚合平台，该平台采用Go语言开发，具有极低的资源占用和快速的响应速度，特别适合追求高效阅读体验的用户，如果您对这款轻量级RSS阅读器感兴趣，想要亲自体验它的强大功能，比如文章分类管理、快捷键操作、多设备同步等特性，欢迎在评论区留言，Eucalyptus会热情地为每位感兴趣的朋友创建专属测试账号，让您零门槛感受Miniflux的独特魅力。

MySQL8.0.30中redo log的变化

Wed, 29 Oct 2025 14:42:21 GMT

MySQL8.0.30 redo log 动态调整

MySQL redo log记录数据记录变更，以及未数据一致性恢复提供保障。在运维MySQL 过程中，会遇到调整redo log 和redo buffer size 大小的需求，然而修改redo log 文件大小需要重启，不过 MySQL 8.0.30 版本中提供动态调整redo log 文件大小的功能。

https://dev.mysql.com/doc/refman/8.0/en/innodb-parameters.html

从 MySQL 8.0.30 开始， innodb_redo_log_capacity系统变量控制 redo log 总的大小。

因为在该版本以及之后的版本参数innodb_log_file_size 和 innodb_log_files_in_group 已经被废弃。

如下图所示，8.0.30 版本对原来的循环覆盖写的结构进行了改造，不再以 redo 文件个数和单个 redo 文件的大小来进行限制，而是通过 innodb_redo_log_capacity来指定整个 redo 空间的大小。整个redo空间会被切成32个文件（固定个数），文件按照 ib_redo$SEQ 的方式进行编号，$SEQ 是一个递增的序列号。在文件管理上，所有的文件会被分成两类：

normal redo 文件，命名为 ib_redo$SEQ，正常的 redo 文件，和以前一样，任意时刻只会有一个 redo 文件进行写入；
unused redo 文件，命名为 ib_redo$SEQ_tmp，未被使用的 redo 文件在被使用时，会被重命名为正常文件；

后台的 log_files_governor 线程会负责处理已经写完成的文件，在满足回收条件时，会重新变成 unused redo 文件

当 innodb_redo_log_capacity 发生变化时，已经使用过的和正在使用过的 redo 文件并不会发生改变，仅需要调整 unused redo 文件。当用户修改 innodb_redo_log_capacity 时，会唤醒后台的 log_files_governor 线程，后台线程首先会重新计算当前的 redo_log_capacity，然后根据变化的类型：

如果是空间放大，直接根据放大后的大小，重新生成新的 unused redo 文件；
如果是空间缩小，需要计算当前已使用的空间数能否满足目标值，如果满足，那么缩小过程和放大过程一样，直接重新生成新的 ununsed redo 文件即可；如果不能，还需要在更新 redo_log_capacity 之后，通过调整暴露给 log_writer 和 page_cleaner 线程的 lsn 信息，来加速空间回收；

unused redo 文件的引入，类似于引入了缓存区的机制，因为 unused redo 文件不是正在使用的 redo 文件，所以可以直接进行重建，从而满足 innodb_redo_log_capacity 的设置。

在运行时设置时，配置更改会立即发生，但可能需要一些时间才能完全实现新的限制。如果重做日志文件占用的空间小于指定值，则脏页将从缓冲池中较不积极地刷新到表空间数据文件中，最终增加重做日志文件所占用的磁盘空间。如果重做日志文件占用的空间超过指定值，则会更积极地刷新脏页，最终减少重做日志文件所占用的磁盘空间。

https://dev.mysql.com/doc/refman/8.0/en/innodb-redo-log.html

MySQL 8.0.17 redo log归档

在需要备份重做日志以满足审计合规要求、进行数据库维护升级或迁移、以及在高负载系统中减少磁盘 I/O 操作对性能影响的情况下特别有用。归档操作应在系统负载较低时进行，并且需要确保归档目录的安全性和正确配置。

在启用 redo log 归档之前，需要创建一个或多个目录来存储归档的 redo log，确保运行 mysqld的系统用户拥有该目录的访问权限。

1
2
3

mkdir -p /var/lib/mysql-redo-archive/backup1
chown -R mysql.mysql /var/lib/mysql-redo-archive
chmod -R 700 /var/lib/mysql-redo-archive/

使用 innodb_redo_log_archive_dirs 全局变量定义标记的归档路径，或者在配置文件种配置，格式为 label:directory-path，可以使用分号分隔多个条目。

1	set global innodb_redo_log_archive_dirs='backup1:/var/lib/mysql-redo-archive/';

1	show variables like 'innodb_redo_log_archive_dirs';

启动和停止归档，具有 innodb_redo_log_archive 权限的用户可以调用 innodb_redo_log_archive_start() 或 innodb_redo_log_archive_stop() 函数来启动或停止归档。

启动

1
2
3

do innodb_redo_log_archive_start('backup1', 'backup1'); 
or
select innodb_redo_log_archive_start('backup1', 'backup1');

停止

1
2
3

do innodb_redo_log_archive_stop();   
or
select innodb_redo_log_archive_stop();

MySQL 8.0.16 redo log加密

MySQL 8.0.16版本以后可以使用innodb_redo_log_encrypt配置选项启用了Redo日志数据加密。默认情况下，Redo日志加密是禁用的。与表空间数据一样，Redo日志数据加密是在将数据写入磁盘时进行的，而解密是在从磁盘读取重做日志数据时进行的。一旦数据读入内存，它就处于未加密形式。使用表空间加密密钥对重做日志数据进行加密和解密。

启用innodb_redo_log_encrypt时，磁盘上存在的未加密Redo日志页面将保持未加密状态，新的Redo日志页面将以加密形式写入磁盘。同样，禁用innodb_redo_log_encrypt时，磁盘上存在的已加密Redo日志页面将保持加密状态，新的Redo日志页面将以未加密形式写入磁盘。

https://dev.mysql.com/doc/refman/8.0/en/innodb-parameters.html

1	SET GLOBAL default_table_encryption=ON;

MySQL 8.0.21 redo log禁用

MySQL 8.0.21版本之后可以启禁用Redo log功能。可以通过避免写入Redo和doublewrite缓冲来加快数据加载。一般初期大量灌入数据是采用。平时就不建议使用此功能，意外发生或服务停止可能会导致数据丢失和实例损坏。

启禁用需要有INNODB_REDO_LOG_ENABLE权限

#启用
ALTER INSTANCE ENABLE  INNODB REDO_LOG;
SHOW GLOBAL STATUS LIKE 'Innodb_redo_log_enabled';
#禁用
ALTER INSTANCE DISABLE INNODB REDO_LOG;

gh-ost菜鸟教程

Wed, 22 Oct 2025 09:30:41 GMT

前言

gh-ost 是 GitHub 开发的一款用于 MySQL 数据库的在线模式迁移解决方案，它支持无触发器的在线模式迁移。这个工具是可测试的，并提供暂停、动态控制/重新配置、审计以及许多操作特权。gh-ost 旨在改变表迁移的范式，它在迁移过程中对主服务器产生的工作量很小，并且与已迁移表上的现有工作负载分离，从而减少对数据库性能的影响。

原理

主要实现原理，首先建两张表，一张_gho的影子表，gh-ost会将原表数据以及增量数据都应用到这个表，最后会将这个表和原表做次表名切换，另一张是_ghc表，这个表是存放changelog的数据，包括信号标记，心跳等。其次，gh-ost会开两个goroutine，一个用于拷贝原表数据，一个用于apply增量的binlog到_gho表，并且两个goroutine的并行在跑的，也就是不用关心数据是先拷贝过去还是先apply binlog过去。因为这里会对insert语句做调整，首先我们拷贝的insert into会改写成insert ignore into，而binlog内insert into会改写成replace into，这样可以很好的支持两个goroutine的并行。但这样的调整能适用所有的DDL吗？答案是否定的。最后，当原表数据全部拷贝完成后，gh-ost会进入到表交换阶段，采用更加安全的原子交换。

过程

检查有没有外键和触发器。
检查表的主键信息。
检查是否主库或从库，是否开启log_slave_updates，以及binlog信息
检查gho和del结尾的临时表是否存在
创建ghc结尾的表，存数据迁移的信息，以及binlog信息等
—以上校验阶段
初始化stream的连接,添加binlog的监听
—以下迁移阶段
创建gho结尾的临时表，执行DDL在gho结尾的临时表上
开启事务，按照主键id把源表数据写入到gho结尾的表上，再提交，以及binlog apply。
—以下cut-over阶段
lock源表，rename 表：rename 源表 to 源_del表，gho表 to 源表。
清理ghc表

安装

由于gh-ost是基于go1.5编译的，故安装gh-ost之前需要安装go，安装go（我的yum仓库中有go包，故直接使用yum安装，没有的话需要进行下载tar包源码安装）

验证go是否安装成功

go env

接下来安装gh-ost，由于gh-ost的tar包再github中，下载的时候可能由于网络的原因导致下载失败，故我们使用gitee中的项目

https://gitee.com/mirrors/gh-ost

我这里直接下载的zip包，然后上传到服务器

下载到服务器上后进行解压

1	unzip gh-ost-master.zip

解压之后进入gh-ost-master目录，

然后再当前的目录下初始化一个git仓库

git init

然后需要在build.sh中指定gh-ost版本

打开build.sh脚本设置你需要的gh-ost版本，然后保存，

1	RELEASE_VERSION=v1.1.7

然后运行build.sh脚本

接下来解压适用于你操作系统的tar包，

1	tar xvzf gh-ost-binary-linux-amd64-20251022142618.tar.gz

最后将gh-ost二进制文件移动到/usr/local/bin下，然后使用gh-ost –version验证gh-ost是否安装成功

1 2	mv gh-ost /usr/local/bin/ gh-ost --version

实战（单节点）

我们创建了一个example_table表，然后使用gh-ost删除这个表中的全文索引ftx_first_name

CREATE TABLE example_table(
    id INT AUTO_INCREMENT,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    email VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    status ENUM('active', 'inactive') DEFAULT 'active',
    PRIMARY KEY (id),
    INDEX idx_last_name (last_name),
    FULLTEXT INDEX ftx_first_name (first_name),
    INDEX idx_status (status),
    INDEX idx_created_at (created_at),
    INDEX idx_first_name_last_name (first_name, last_name)
);

gh-ost \
--host=127.0.0.1 \
--user=root \
--password=123456 \
--database=demo1 \
--table=example_table \
--alter="DROP INDEX ftx_first_name" \
--execute \
--allow-on-master

可以看到example_table中的全文索引ftx_first_name已经删除

通过解析binlog我们可以看到首先gh-ost创建了存放changelog的demo1._example_table_ghc表，然后创建了影子表demo1._example_table_gho

create /* gh-ost */ table `demo1`.`_example_table_ghc` (
                        id bigint unsigned auto_increment,
                        last_update timestamp not null DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                        hint varchar(64) charset ascii not null,
                        value varchar(4096) charset ascii not null,
                        primary key(id),
                        unique key hint_uidx(hint)
                ) auto_increment=256 comment='gh-ost changelog'
/*!*/;

随后在影子表demo1._example_table_gho执行了ddl，并设置了AUTO_INCREMENT

binlog中继续往下看，在end_log_pos 18708，又创建了demo1._example_table_del

create /* gh-ost */ table `demo1`.`_example_table_del` (
                        id int auto_increment primary key
                ) engine=InnoDB comment='ghost-cut-over-sentry'
/*!*/;

在end_log_pos 24355，删除了_example_table_del

在end_log_pos 25086，使用rename了

将demo1.example_table 重命名为demo1._example_table_del

将demo1._example_table_gho重命名为demo1.example_table

最后删除了 _example_table_ghc和 _example_table_ghk

MySQL中的数据类型占用空间和范围

Tue, 14 Oct 2025 03:29:53 GMT

数据类型	描述	占用空间	最大值~最小值 (SIGNED)	最大值~最小值 (UNSIGNED)
TINYINT	微整数	1 byte	-128 ~ 127	0 ~ 255
SMALLINT	小整数	2 bytes	-32768 ~ 32767	0 ~ 65535
MEDIUMINT	中等整数	3 bytes	-8388608 ~ 8388607	0 ~ 16777215
INT 或 INTEGER	整数	4 bytes	-2147483648 ~ 2147483647	0 ~ 4294967295
BIGINT	大整数	8 bytes	-9223372036854775808 ~ 9223372036854775807	0 ~ 18446744073709551615
FLOAT	单精度浮点数	4 bytes	-3.40282347E+38 ~ 3.40282347E+38	0 ~ 3.40282347E+38
DOUBLE	双精度浮点数	8 bytes	-1.7976931348623157E+308 ~ 1.7976931348623157E+308	0 ~ 1.7976931348623157E+308
DECIMAL(M,D)	精确小数，M为总位数，D为小数位	M+2字节	取决于M和D	取决于M和D
DATE	日期	3 bytes	0000-01-01 ~ 9999-12-31	0000-01-01 ~ 9999-12-31
TIME	时间	3 bytes	-838:59:59 ~ 838:59:59	00:00:00 ~ 838:59:59
DATETIME	日期时间	5 bytes	0000-01-01 00:00:00 ~ 9999-12-31 23:59:59	0000-01-01 00:00:00 ~ 9999-12-31 23:59:59
TIMESTAMP	时间戳	4 bytes	1970-01-01 00:00:01 UTC ~ 2038-01-19 03:14:07 UTC	1970-01-01 00:00:01 UTC ~ 2038-01-19 03:14:07 UTC
YEAR	年份	1 byte	1901 ~ 2155	1901 ~ 2155
CHAR(M)	固定长度字符串	M bytes	空字符串 ~ M字符字符串	空字符串 ~ M字符字符串
VARCHAR(M)	可变长度字符串	长度 + 1 byte	空字符串 ~ M字符字符串	空字符串 ~ M字符字符串
TINYTEXT	小文本	长度 + 1 byte	空字符串 ~ 255字符字符串	空字符串 ~ 255字符字符串
TEXT	文本	长度 + 2 bytes	空字符串 ~ 65,535字符字符串	空字符串 ~ 65,535字符字符串
MEDIUMTEXT	中等文本	长度 + 3 bytes	空字符串 ~ 16,777,215字符字符串	空字符串 ~ 16,777,215字符字符串
LONGTEXT	大文本	长度 + 4 bytes	空字符串 ~ 4,294,967,295字符字符串	空字符串 ~ 4,294,967,295字符字符串
BINARY(M)	固定长度二进制字符串	M bytes	空字符串 ~ M字节字符串	空字符串 ~ M字节字符串
VARBINARY(M)	可变长度二进制字符串	长度 + 1 byte	空字符串 ~ M字节字符串	空字符串 ~ M字节字符串
TINYBLOB	小BLOB	长度 + 1 byte	空二进制字符串 ~ 255字节	空二进制字符串 ~ 255字节
BLOB	BLOB	长度 + 2 bytes	空二进制字符串 ~ 65,535字节	空二进制字符串 ~ 65,535字节
MEDIUMBLOB	中等BLOB	长度 + 3 bytes	空二进制字符串 ~ 16,777,215字节	空二进制字符串 ~ 16,777,215字节
LONGBLOB	大BLOB	长度 + 4 bytes	空二进制字符串 ~ 4,294,967,295字节	空二进制字符串 ~ 4,294,967,295字节
ENUM(‘value1’,…)	枚举，预定义字符串列表中选择	1~2 bytes	取决于枚举值	取决于枚举值
SET(‘value1’,…)	集合，预定义字符串列表中选择	1~8 bytes	取决于集合值	取决于集合值
BIT(M)	位字段	M bits	0 ~ 2^M - 1	0 ~ 2^M - 1
GEOMETRY	空间几何数据类型	可变	取决于数据大小	取决于数据大小
POINT	点类型	可变	取决于数据大小	取决于数据大小
LINESTRING	线字符串类型	可变	取决于数据大小	取决于数据大小
POLYGON	多边形类型	可变	取决于数据大小	取决于数据大小
JSON	JSON数据类型	可变	取决于JSON数据大小	取决于JSON数据大小

MySQL中的空间碎片率计算分析

Sat, 11 Oct 2025 06:12:41 GMT

空间碎片的类型

MySQL 中的空间碎片主要分为两种类型：数据碎片和索引碎片。

数据碎片

数据碎片是指表中的数据页（或数据块）中未被充分利用的空间。数据页是 MySQL 存储数据的基本单位，通常大小为 16 KB（对于 InnoDB 存储引擎）。

INSERT** 操作**：插入数据时，如果插入的数据量较小，可能会导致数据页没有被完全填满，从而产生未使用的空间。
DELETE** 操作**：删除数据时，被删除的数据行所占用的空间会变成未使用的空间。如果这些空间没有被后续的 INSERT 操作重新利用，就会形成碎片。
UPDATE** 操作**：如果更新操作导致数据行的大小发生变化（例如，从较短的字符串更新为较长的字符串），可能会导致数据行被移动到新的数据页，从而产生碎片。

索引碎片

索引碎片是指索引中的索引页（或索引块）中未被充分利用的空间。索引页是 MySQL 存储索引信息的基本单位，通常大小为 16 KB（对于 InnoDB 存储引擎）。

INSERT** 操作**：插入数据时，如果插入的数据行导致索引页分裂，可能会产生未使用的空间。
DELETE** 操作**：删除数据时，被删除的数据行所占用的索引空间会变成未使用的空间。如果这些空间没有被后续的 INSERT 操作重新利用，就会形成碎片。
UPDATE** 操作**：如果更新操作导致索引键值的变化，可能会导致索引页的重新组织，从而产生碎片。

碎片的危害

增加磁盘 I/O 操作：当存在存储碎片时，数据在磁盘上的存储位置变得分散。例如，一个查询原本只需要读取一个连续的数据块就能获取所需信息，但由于碎片的存在，数据可能分布在多个不连续的磁盘位置。这就导致数据库在执行查询操作时，需要多次进行磁盘 I/O 操作来读取分散的数据。对于频繁查询的数据库系统，大量的额外磁盘 I/O 会显著降低系统的整体性能。
降低存储效率：在 MySQL 中，缓冲池（如 InnoDB 缓冲池）用于缓存数据页和索引页，以减少磁盘 I/O。但是，碎片会使数据页和索引页在缓冲池中难以高效地缓存。由于碎片导致数据页不完整或部分空闲，缓冲池可能无法充分利用其空间来缓存完整的、经常使用的数据页。
造成磁盘空间浪费：存储碎片使得磁盘空间无法得到有效利用。这些碎片空间单个可能较小，但随着时间的推移和操作的积累，它们会占用大量的磁盘空间。例如，在一个数据库表空间中，由于数据的删除和更新操作产生了许多小碎片，这些碎片空间加起来可能占据了相当大的磁盘容量，但却无法被有效地用于存储新的数据。

空间碎片率计算公式

8.0

SELECT  
  TABLE_NAME,
  TABLE_ROWS,
  ROUND(DATA_LENGTH / (1024 * 1024 * 1024), 2) AS DATA_LENGTH_GB,
  ROUND(INDEX_LENGTH / (1024 * 1024 * 1024), 2) AS INDEX_LENGTH_GB,
  DATA_FREE,
  CASE 
    WHEN (DATA_LENGTH + INDEX_LENGTH + DATA_FREE) > 0 THEN 
      ROUND(DATA_FREE / (DATA_LENGTH + INDEX_LENGTH + DATA_FREE) * 100, 2) 
    ELSE 
      0 
  END AS Space_debris_rate,
  (SELECT ROUND(FILE_SIZE / (1024 * 1024 * 1024), 2) 
   FROM information_schema.innodb_tablespaces 
   WHERE name = 'demo1/example_table') AS FILE_SIZE_GB
FROM information_schema.tables 
WHERE table_schema = 'demo1' AND table_name = 'example_table';

5.7

SELECT  
  table_name,
  table_rows,
  ROUND(data_length / (1024 * 1024 * 1024), 2) AS data_length_gb,
  ROUND(index_length / (1024 * 1024 * 1024), 2) AS index_length_gb,
  data_free,
  CASE 
    WHEN (data_length + index_length + data_free) > 0 THEN 
      ROUND(data_free / (data_length + index_length + data_free) * 100, 2) 
    ELSE 
      0 
  END AS space_debris_rate
FROM information_schema.tables 
WHERE table_schema = 'demo1' AND table_name = 'example_table';

单个节点空间碎片率分析

创建example_table，然后使用存储过程插入2千万行数据

CREATE TABLE example_table(
    id INT AUTO_INCREMENT,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    email VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    status ENUM('active', 'inactive') DEFAULT 'active',
    PRIMARY KEY (id),
    INDEX idx_last_name (last_name),
    FULLTEXT INDEX ftx_first_name (first_name),
    INDEX idx_status (status),
    INDEX idx_created_at (created_at),
    INDEX idx_first_name_last_name (first_name, last_name)
);

DELIMITER //

CREATE PROCEDURE InsertTwentyMillionRows()
BEGIN
    DECLARE v_max INT DEFAULT 20000000; -- 总行数
    DECLARE v_batch_size INT DEFAULT 1000; -- 每次插入的行数：1000
    DECLARE v_count INT DEFAULT 0; -- 当前插入的行数

    START TRANSACTION;

    -- 循环直到达到目标行数
    WHILE v_count < v_max DO
        -- 插入1000行数据
        INSERT INTO example_table (first_name, last_name, email, status)
        SELECT
            CONCAT('FirstName', LPAD((v_count * v_batch_size) + num, 7, '0')) AS first_name,
            CONCAT('LastName', LPAD((v_count * v_batch_size) + num, 7, '0')) AS last_name,
            CONCAT('user', LPAD((v_count * v_batch_size) + num, 7, '0'), '@example.com') AS email,
            CASE WHEN ((v_count * v_batch_size) + num) % 2 = 0 THEN 'active' ELSE 'inactive' END AS status
        FROM (
            SELECT a.num + (b.num * 10) AS num
            FROM (
                SELECT 0 AS num UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9
            ) a
            CROSS JOIN (
                SELECT 0 AS num UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9
            ) b
        ) AS subquery;

        -- 更新当前插入的行数
        SET v_count = v_count + v_batch_size;

        -- 每插入100000行数据，提交一次事务，避免事务过大导致性能问题
        IF v_count % 100000 = 0 THEN
            COMMIT;
            START TRANSACTION;
        END IF;
    END WHILE;

    COMMIT;
END //

DELIMITER ;

1	CALL InsertTwentyMillionRows();

查看information_schema.tables表中的信息

delete删除表中的所有数据，并使用上述sql查看碎片率

再次查看information_schema.tables表中的统计信息，没有变化，使用analyze更新统计信息

再次查看information_schema.tables表中的统计信息，发现已更新，这时在次使用上述sql查看碎片率，发现碎片率变到99.98%

最后使用optimize重建表后发现碎片率归0

这里有时执行optimize后data_free并不会完全归零，这是因为InnoDB 存储引擎在表空间中预留了一部分空间，用于未来的插入操作。这是为了提高插入性能，避免频繁的页分裂。即使表空间被重新组织，InnoDB 也会保留这部分预留空间，因此 data_free 不会完全归零。当然除了预留空间外，还可能包括未使用的页、表空间的最小单位、并发操作以及存储引擎的限制。

表空间和页的概念

表空间（Tablespace）：InnoDB 使用表空间来存储数据和索引。表空间是由一个或多个文件组成的，这些文件可以是单个文件（如 ibdata1）或多文件表空间（如 .ibd 文件）。表空间是 InnoDB 存储数据和索引的基本单位。
页（Page）：页是表空间中存储数据和索引的基本单位，通常大小为 16 KB。每个页可以存储多行数据或索引条目。InnoDB 通过页来管理数据和索引的存储。

预留空间的目的

InnoDB 在表空间中预留一部分空间的主要目的是为了优化插入操作和减少碎片化。以下是具体原因：

提高插入性能

预留空间：当表中插入新数据时，InnoDB 会尝试将新数据插入到预留空间中。预留空间的存在减少了频繁分配新页的需要，从而提高了插入操作的效率。
减少页分裂：如果没有预留空间，插入操作可能会导致页分裂。页分裂是指一个页满了之后，InnoDB 会将页中的数据分成两部分，分别存储在两个新的页中。页分裂会增加碎片化，降低读写性能。预留空间可以减少页分裂的发生。

减少碎片化

减少未使用空间：预留空间可以减少表空间中的未使用空间（DATA_FREE）。通过预留一部分空间，InnoDB 可以更有效地利用表空间，减少碎片化的产生。
优化存储管理：预留空间有助于优化表空间的存储管理，减少表空间的碎片化，提高存储效率。

主从节点空间碎片率分析

使用上述相同的方式插入2千万行数据，可以发现主节点和只读节点的空间碎片率和物理文件存在差异

在主节点执行analyze更新统计信息

这时碎片率有所上升，但是主和只读还是不完全相等

主库和只读实例的碎片率出现较大差异的原因分析

复制原理与多线程复制

逻辑复制原理：MySQL 的逻辑复制是基于二进制日志（binlog）的。主库将数据变更操作记录到 binlog 中，从库通过 I/O 线程读取主库的 binlog，并将其存储到本地的中继日志（relay log）中。然后，从库的 SQL 线程会读取 relay log 并应用这些变更。
多线程复制：为了提高复制效率，MySQL 支持多线程复制。在多线程复制中，从库可以使用多个 SQL 线程并行地应用 relay log 中的事件。这可以显著提高复制的性能，但也会引入一些复杂性。

多线程复制中的顺序问题

事务依赖性：在单线程复制中，SQL 线程会严格按照 binlog 中的顺序应用事件，确保数据的一致性。但在多线程复制中，多个 SQL 线程可能会并行地应用 relay log 中的事件。如果这些事件之间存在依赖关系（例如，一个 INSERT 操作依赖于之前的某个 DELETE 操作），并行应用可能会导致顺序发生变化。
分组提交：MySQL 的多线程复制支持分组提交（Group Commit），即将多个事件分组后并行提交。虽然 MySQL 会尽量保证分组内的事件顺序，但不同分组之间的事件顺序可能会发生变化。

碎片率差异的原因

INSERT 和 DELETE 操作顺序变化：如果只读实例的 INSERT 和 DELETE 操作顺序与主库不同，可能会导致数据分布和索引结构的变化。例如，主库中先执行了一个 DELETE 操作，然后执行了一个 INSERT 操作，而只读实例中这两个操作的顺序相反，这可能会导致只读实例中的数据碎片率增加。
索引维护差异：INSERT 和 DELETE 操作会影响索引的维护。如果操作顺序不同，索引的分裂和合并操作也会不同，从而导致索引碎片率的差异。
并发写入和删除：在多线程复制中，多个线程可能会同时对同一个表进行写入和删除操作。如果这些操作的顺序不一致，可能会导致数据页的碎片化。例如，一个线程在某个数据页中插入了大量数据，而另一个线程在同一个数据页中删除了部分数据，这可能会导致数据页的碎片化。

Miniflux – RSS 订阅

Tue, 07 Oct 2025 12:12:24 GMT

什么是Miniflux

Miniflux 是一个用 Go 写的极简开源 RSS 阅读器，单二进制 +内建 Web UI，五分钟就能容器化跑起来；它默认 Fever API、内存占用极低，界面干净无广告，适合只想安静看文章、不想折腾样式插件的极简党。

核心功能与特点

极简设计：功能精简，专注于核心阅读体验。
高性能：基于 Go 语言开发，单二进制文件，无依赖。
轻量且快速：资源占用低，响应迅速。
现代技术栈：使用现代 JavaScript（ES6 和 Fetch API），无复杂框架。
单一数据库支持：仅支持 PostgreSQL，确保数据一致性和性能。
易于安装：提供 Docker 镜像，一键部署。

适用场景

极简主义爱好者：追求简洁、高效的新闻阅读体验。
开发者：通过 API 集成到其他应用中。
低资源环境：在树莓派等低性能设备上运行。

官方地址

官方网站：https://miniflux.app
GitHub 仓库：https://github.com/miniflux/v2

前提条件

在开始部署之前，请确保你的系统已经安装了 Docker 和 Docker Compose。如果尚未安装，请参考Eucalyptus写的Centos7下安装Docker-CSDN博客，

创建 Docker Compose 配置文件

命令行部署

首先登录你部署Miniflux的服务器，然后创建个docker-compose.yml文件

services:
  miniflux:
    image: miniflux/miniflux:latest
    ports:
      - "80:8080"
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgres://miniflux:admin@123@db/miniflux?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=admin@123
    healthcheck:
      test: ["CMD", "/usr/bin/miniflux", "-healthcheck", "auto"]

  db:
    image: postgres:17-alpine
    environment:
      - POSTGRES_USER=miniflux          # 与 DATABASE_URL 用户一致
      - POSTGRES_PASSWORD=admin@123
      - POSTGRES_DB=miniflux
    volumes:
      - miniflux-db:/var/lib/postgresql/data   # 官方默认路径
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "miniflux"]  # 用户一致
      interval: 10s
      start_period: 30s

volumes:
  miniflux-db:

接下来再当前目录下直接执行下述命令即可

1	docker compose up -d

宝塔可视化部署

当然也可完全使用宝塔可视化部署，在宝塔中的docker容器编排这里部署

compose内容

version: "3.9"

services:
  miniflux:
    image: miniflux/miniflux:latest
    ports:
      - "${MINIFLUX_PORT}:8080"          # ← 变量
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgres://${DB_USER}:${DB_PASS}@db/${DB_NAME}?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=${ADMIN_USER}
      - ADMIN_PASSWORD=${ADMIN_PASS}
    healthcheck:
      test: ["CMD", "/usr/bin/miniflux", "-healthcheck", "auto"]

  db:
    image: postgres:17-alpine
    environment:
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASS}
      - POSTGRES_DB=${DB_NAME}
    volumes:
      - miniflux-db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "${DB_USER}"]
      interval: 10s
      start_period: 30s

volumes:
  miniflux-db:

.env内容

# Miniflux 外部端口
MINIFLUX_PORT=80

# 数据库三要素
DB_USER=miniflux
DB_PASS=admin@123
DB_NAME=miniflux

# 管理员账号
ADMIN_USER=admin
ADMIN_PASS=admin@123

Miniflux订阅RSS

到这里Miniflux已经部署完成了，接下来在浏览器访问http://:80即可，ip使用你部署Miniflux服务器的公网ip，Miniflux的用户是admin，密码是admin@123，pg的用户名是miniflux，密码是admin@123

输入Miniflux密码进行登录

刚进去的是英文界面，可以在set设置简体中文

然后添加订阅源，输入你要订阅BLOG的RSS地址例如：https://mingliang.net.cn/feed/

然后就可以看到BLOG的文章内容了

总结

到这里Miniflux就完成了部署并且订阅了Blog的RSS，整个过程仅需几分钟就能搭建起一个轻量高效的RSS阅读平台，你可以通过网页端随时随地获取最新内容更新，无需担心广告干扰或算法推荐；如果你不方便自行部署的话，可以_留言申请Eucalyptus_部署的Miniflux服务的用户名进行体验，我们提供免费的测试账号供你试用一周，期间你可以完整体验Miniflux的所有功能，包括多设备同步、快捷键操作、文章收藏等特色功能，感受这款开源RSS阅读器的简洁与高效。

PostgreSQL编译安装教程

Mon, 29 Sep 2025 03:14:05 GMT

系统环境

操作系统：CentOS 7.6.1810
PostgreSQL版本： 16.0

下载压缩包

官网地址：PostgreSQL: File Browser

下载压缩包

1	wget https://ftp.postgresql.org/pub/source/v16.0/postgresql-16.0.tar.gz

解压压缩包

1	tar -xzvf postgresql-16.0.tar.gz

查看解压文件

解压之后会看到下面的文件

编译安装

编译

进入postgresql-16.0目录，编译configure文件

1	./configure --prefix=/usr/local/pgsql

参数：–prefix=/usr/local/pgsql
表示编译好的文件放到目录”/usr/local/pgsql”里，这个目录不用用户自己创建，编译过程会自动创建。

注意事项：

PostgreSQL编译过程会用到一些依赖的库，如果你的操作系统比较旧，编译过程可能会出现错误，告诉你要安装缺少的依赖库。

看到./config.status说明编译完成，可以看见config.status文件

安装

1	make && make install

完成以后，在”–prefix=/usr/local/pgsql”参数对应的”/usr/local/pgsql”的目录就是我们所有PostgreSQL存放的文件，这里的这个data和log文件现在是没有的。

用户权限和环境变量设置

编译安装成功后，接下来要做的就是创建一个普通用户，因为默认Linux超级用户（root）不能启动PostgreSQL，所以需要创建一个普通用户来操作数据库。

创建用户

#创建用户组postgres
groupadd postgres
#创建用户postgres并设置groups、gid和家目录
useradd -g postgres -G postgres -d /home/postgresql postgres 
#设置用户密码
passwd postgres

注意当前路径是在/usr/local/pgsql下

1	mkdir data log

设置权限

接下来需要设置权限，将/usr/local/pgsql (我们安装PostgreSQL数据库的目录) 目录全部赋权给postgres用户

1	chown -R postgres.postgres /usr/local/pgsql/

设置环境变量

为了方便起见设置一下相关的环境变量，此处是要设置postgres用户的环境变量，所以首先要把Linux的登陆用户由root切换到以postgres用户登陆。

1	su - postgres

因为我们创建Linux用户”postgres”是指定了用户的目为”/home/postgresql”，所以登陆后显示的目录是：/home/postgresql

要创建环境变量，实际上就是对文件.bash_profile的修改，所以我们首先要找到这个文件，这个文件就在”/home/postgresql”里，由于这个文件是隐藏文件所以要加-a参数

ll -a

编辑.bash_profile文件

1	vim .bash_profile

添加下面的内容

使配置的环境变量生效

1	source /home/postgresql/.bash_profile

检查是否生效

psql -V

看到安装PostgreSQL的版本号则代表生效

初始化数据库

新安装的PostgreSQL数据库系统，要先初始化基本的基础数据库，然后我们才能在上面创建我们自己的数据库。初始化数据库的指令是”initdb”，这个指令位于”/usr/local/pgsql/bin/“

我们可以用指令”initdb –help”看看这个文件的帮助信息。

如上图，可以看到在使用”initdb”进行初始化的时，可以指定参数进行一些初始化工作，例如指定pgdata（postgresql数据库目录）、指定encoding（编码）、指定数据库超级用户的用户名和密码等等。注意，如果pgdata目录没有指定，则会默认使用环境变量中的PGDATA指定的目录作为数据库存放的目录，由于之前我们刚刚设置了”PGDATA=/usr/local/pgsql/data”环境变量，所以此处我们也就无需再额外指定，直接执行初始化命令即可。

initdb

若是执行initdb看到下面报错，说明现在登陆的不是postgres用户，需要切换到postgres用户来执行initdb命令

看到下面信息就代表成功

同时在”/usr/local/pgsql/data]”的目录可以看到生成的数据和配置文件等。

base目录是表空间目录
global目录是相关全局变量的目录
pg_hba.conf是访问控制配置，127.0.0.1改为信任的客户端ip网段使其可以远程访问
postgresql.conf是PostgreSQL主配置文件，”listen_address=localhost”改为”*”使其监听整个网络，方便起见我这里将pg_hba.conf的ip地址修改为0.0.0.0/0，而加密方式改为md5，就表示需要密码访问，算是提供一个最低级的安全防护

数据库访问控制配置文件

主要是配置postgresql.conf 和 pg_hba.conf 个。

postgresql.conf 针对实例的配置
pg_hba.conf 针对数据库访问的控制

postgresql.conf

1	vim postgresql.conf

pg_hba.conf

1	vim pg_hba.conf

PostgreSQL启动与关闭

手动

启动与关闭数据库是执行pg_ctl命令，在执行时，需要指定数据库路径和日志文件路径，格式如下。

1	pg_ctl -D <数据存放路径> -l <日志文件路径> [ stop \| start ]

如果已经指定了环境变量PGDATA，”数据存放路径”参数可以省略。

1	pg_ctl -D /usr/local/pgsql/data -l /usr/local/pgsql/log/pg_server.log start

自动

此步骤需要root用户操作，如果你是用PostgreSQL的用户postgres登陆的话，要用exit指令退出，回到root登陆才能操作。
PostgreSQL解压后的安装包目录中提供了数据库启动与关闭的脚本，此脚本不但可以帮助我们简化操作，而且可以用作开机启动的脚本和service/systemctl 控制服务的脚本。目录里”linux”文件就是我们要找的文件。

如果找不到linux文件可以执行下面命令查看

1	find / -name macos

把文件”linux”拷贝到目录”etc/init.d/“下，并改名为postgresql。
把脚本文件”postgresql”加入到开机启动的程序列表。
赋予”postgresql”文件有执行的权限。

1
2
3

cp /opt/postgresql/postgresql-16.0/contrib/start-scripts/linux /etc/init.d/postgresql
chkconfig --add postgresql或者systemctl enable postgresql
chmod 755 /etc/init.d/postgresql

主要设置文件”postgresql”的四个变量的值。

1	vim /etc/init.d/postgresql

prefix 是软件的安装路径
PGDATA 是数据存放路径
PGUSER 是启动PostgreSQL服务器的用户
PGLOG 是日志文件

以后可以开机启动和通过service命令控制启动和关闭了。

1	service postgresql start/stop

客户端测试连接

可以通过PostgreSQL自带的客户端工具程序psql来进行连接，这个psql指令文件位于/usr/local/pgsql/bin目录下，因为我们做了变量环境设置，所以可以在任何目录下直接输入psql连接PostgreSQL服务器。温馨提示：用客户端程序psql连接数据库前，要把当前Linux登陆用户从root切换到postgres用户，这个是我们创建的PostgreSQL的超级用户。

1 2	su - postgres psql

可以看到，已经连接上了数据库服务器。

设置用户postgres密码

1	postgres=# \password

命令”\l”是显示数据库。更多的SQL操作命令可以参考PostgreSQL的官方文档。退出pgsql客户端命令是”\q”或者exit

DBeaver连接测试

测试连接成功

PostgreSQL安装到此完毕。

MySQL抛出的Public Key Retrieval is not allowed

Wed, 10 Sep 2025 06:37:45 GMT

有时候在连接实例的时候会遇到这样的报错Public Key Retrieval is not allowed

问题分析

这是因为账号使用了caching_sha2_password 密码插件

而caching_sha2_password 插件为了加快认证过程，在服务端维护了一个密码哈希缓存。当客户端发起连接时：

如果用户的密码哈希已经被缓存，服务端可以直接验证，无需客户端发送明文密码进行验证。
如果缓存中没有该用户的密码哈希，则客户端需要发送明文密码进行认证。

在发送明文密码时，出于安全考虑，MySQL 要求：

要么客户端和服务端之间建立 SSL 加密连接。
要么客户端允许通过服务端公钥加密明文密码。

如果两者都不满足，就会抛出 Public Key Retrieval is not allowed 错误。

以下三种情况会导致缓存中没有用户的密码哈希

发生重启
发生HA
有操作flush privileges

解决方法

1、客户端的话可以设置驱动中的allowPublicKeyRetrieval=true

2、JDBC的话可以在连接字符串中添加allowPublicKeyRetrieval=true参数，以允许公钥检索。

1	jdbc:mysql://localhost:3306/?allowPublicKeyRetrieval=true

3、将账号的密码插件改为mysql_native_password

注意事项

设置allowPublicKeyRetrieval=true的方法会自动从 MySQL 服务端获取 RSA 公钥，但这种方法有一定的安全风险，可能会受到中间人攻击。攻击者可以伪造 RSA 公钥，窃取用户密码。

Wordpress登录页面DIY

Mon, 01 Sep 2025 12:37:45 GMT

由于部分WordPress主题在默认配置下没有对后台登录界面进行定制化开发，用户只能使用系统自带的原生登录页面，这种页面往往设计简陋、缺乏品牌特色，与网站整体风格格格不入，影响了用户体验和品牌形象；为此，我通过深入研究WordPress的login_head和login_footer钩子，对原生登录页面进行了全面的二次开发，不仅替换了默认的WordPress logo为网站品牌标识，还重新设计了登录表单的布局和配色方案，增加了背景图片和CSS3动画效果，同时优化了移动端的响应式布局，使登录页面与网站主题风格完美统一，大大提升了后台管理的专业性和视觉体验。

源码下载地址：https://gitcode.com/weixin_72610956/Blog/tree/login

1
2
3

#下述了两个代码文件均放置到主题目录下的自建self-innovate文件中
login-style.php
login-style.css

核心代码


/**
 * 登录页美化（Logo 完全禁用点击）
 */
add_action( 'login_enqueue_scripts', function () {
    wp_enqueue_style( 'my-login', get_theme_file_uri( '/self-innovate/login-style.css' ), [], '1.0.0' );
} );

/* 完全移除  的 href，避免刷新 */
add_filter( 'login_headerurl', function () {
    return 'javascript:void(0);';   // 真正无动作
} );

/* 悬停文字留空，防止提示 */
add_filter( 'login_headertext', '__return_empty_string' );

下述是css代码，需替换css中body.login和login::before的background:url(”)路径

/* 1. 背景与斜遮罩 */
body.login{
  height:100vh;
  margin:0;
  display:flex;
  align-items:center;
  justify-content:center;
  background:url('https://mingliang.net.cn/wp-content/uploads/2025/05/16-scaled.jpg') center/cover no-repeat;
  position:relative;
}
body.login::before{
  content:'';
  position:absolute;
  inset:0;
  background:linear-gradient(-75deg, transparent 0% 50%, rgba(255,255,255,.6) 50% 100%);
  z-index:1;
}

/* 2. 登录框整体定位与 Logo */
#login{
  position:relative;
  z-index:2;
  width:340px;
  padding:40px 40px 40px; /* 40px+140px空间已含在顶部padding */
  padding-top:140px;      /* 给Logo留空间 */
  margin-left:150px;
}
#login::before{           /* Logo伪元素 */
  content:'';
  position:absolute;
  top:20px;
  left:50%;
  transform:translateX(-50%);
  width:160px;
  aspect-ratio:1;
  background:url('https://images.mingliangstar.com/logo/logo1.avif?imageslim') center/contain no-repeat;
  pointer-events:none;
}

/* 3. 表单 */
body.login form#loginform{
  margin:24px 0 !important;
  padding:26px 24px !important;
  box-shadow:0 1px 3px rgba(0,0,0,.04) !important;
  background:transparent !important;
  border:none !important;
}

/* 4. 文字Logo */
.login h1 a{
  background:none !important;
  text-indent:0;
  width:auto;
  height:auto;
  font:700 24px/1.2 sans-serif;
  color:#333;
  margin-bottom:24px;
}

/* 5. 输入框 */
.login form .input{
  border:1px solid #e1e5e9;
  border-radius:8px;
  padding:12px 16px;
  font-size:15px;
  transition:border-color .3s, box-shadow .3s;
}
.login form .input:focus{
  border-color:#667eea;
  box-shadow:0 0 0 2px rgba(102,126,234,.25);
}

/* 6. 按钮 */
.wp-core-ui .button-primary{
  width:100%;
  border:none;
  border-radius:30px;
  padding:12px 0;
  font:600 16px/1 sans-serif;
  background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);
  transition:transform .3s;
}
.wp-core-ui .button-primary:hover{
  transform:translateY(-2px);
  box-shadow:0 6px 20px rgba(102,126,234,.45);
}

/* 7. 隐藏语言切换 */
#language-switcher{display:none !important;}

最后需再functions.php中调用该模块

1	require_once get_theme_file_path( '/self-innovate/login-style.php' );

20250831主题友链页面自研

Sun, 31 Aug 2025 13:47:25 GMT

20250831主题虽然设计简约现代，但由于缺乏原生的友情链接管理功能，许多博主只能将友情链接勉强添加在网站底部，这不仅影响页面美观，也不便于访客查找和互动；为了解决这一痛点，本博主对主题进行了深度二次开发，专门打造了一个独立的友情链接页面，该页面不仅实现了友链分类展示、图文混排等基本功能，更创新性地开发了前端提交表单，允许其他站长直接在线提交申请，同时配套开发了完善的后台审核系统，管理员可以便捷地查看申请信息、审核状态，并一键通过或拒绝，整个流程实现了自动化闭环管理，大大提升了友链交换的效率和用户体验。

源码下载地址：https://gitcode.com/weixin_72610956/Blog/tree/link

default-avatar.jpg
page-links.css
page-links.js
pending-links.php

以下是核心代码部分，这段代码实现了系统的关键功能，

并且这里对友链头像有三个判断的逻辑

有头像 → 正常显示；
无头像 → 立即显示默认头像；
有头像但 3 秒仍未加载完成 → 自动替换成默认头像。


/*
 * Template Name: 友情链接
 * Description:  极简友链模板（样式/脚本已分离，含评论）
 */

get_header(); 
?>

class="hero-title">
  php the_title( '<h1>', 'h1>' ); ?>
  <p class="hero-sub">欢迎交换友链 · 携手点亮彼此的星空p>
div>



<link rel="stylesheet" href="php echo get_template_directory_uri(); ?>/self-innovate/page-links.css">

<div class="page-links">

  
  <div class="link-search">
    <input type="text" id="link-search" placeholder="搜索站点名称或描述…">
  div>

  
  php
  $cats = get_terms( 'link_category', array( 'hide_empty' => 0 ) );
  foreach ( $cats as $cat ) :
    $bookmarks = get_bookmarks( array(
      'category' => $cat->term_id,
      'orderby'  => 'rating',
      'order'    => 'DESC'
    ) );
    if ( empty( $bookmarks ) ) continue;
  ?>
    <div class="link-cat">
      <h2>php echo esc_html( $cat->name ); ?>h2>
      php if ( ! empty( $cat->description ) ) : ?>
        <p class="link-cat-desc">php echo esc_html( $cat->description ); ?>p>
      php endif; ?>
      <div class="links">
      php foreach ( $bookmarks as $link ) : ?>
        <a class="link-card" href="php echo esc_url( $link->link_url ); ?>" target="_blank" rel="noopener">
        <img
          src="php echo esc_url( $link->link_image ?: '' ); ?>"
          data-default="php echo esc_url( get_template_directory_uri() . '/self-innovate/default-avatar.jpg' ); ?>"
          alt="php echo esc_attr( $link->link_name ); ?>"
          onerror="this.src=this.dataset.default"
          onload="clearTimeout(this.t)"
          ontimeout="this.src=this.dataset.default"
      />
        <script>
          (function(img){
            img.t = setTimeout(function(){ img.src = img.dataset.default; }, 3000);
          })(document.currentScript.previousElementSibling);
        
          class="info">
            <div class="name">php echo esc_html( $link->link_name ); ?>div>
            <div class="desc">php echo esc_html( $link->link_description ); ?>div>
          div>
        a>
      php endforeach; ?>
      div>
    div>
  php endforeach; ?>

    
  php if ( get_the_content() ) : ?>
    <div class="link-intro" style="margin-bottom:30px;">php the_content(); ?>div>
  php endif; ?>

  
  
  <div class="btn-center">
    <button id="open-link-modal" class="btn-hero">
      <span>申请交换友链span>
    button>
  div>


  
    php
    // while ( have_posts() ) : the_post();
        if ( comments_open() || get_comments_number() ) : ?>
            <section class="link-comments">
                <h2 class="comments-title">h2>
                php comments_template(); ?>
            section>
        php
        endif;
    // endwhile;
    ?>

  
  <div id="link-modal-overlay" class="modal-fade">
    <div class="modal-dialog">
      <button class="modal-close" aria-label="关闭">×button>
      <h3 class="modal-title">申请交换友链h3>
      <form id="link-form" class="modal-form">
        <input type="text"   name="link_name"        placeholder="网站名称 *" required>
        <input type="url"    name="link_url"         placeholder="网站地址 *" required>
        <input type="email"  name="link_owner_email" placeholder="站长邮箱 *" required>
        <input type="url"    name="link_image"       placeholder="头像 / Logo *" required>
        <textarea name="link_description" rows="3" placeholder="一句话描述 *" required>textarea>
        <button type="submit" class="btn-submit">提交申请button>
        <p id="form-msg" class="form-msg">p>
      form>
    div>
  div>
div>


<script>
  var ajax_comment_obj = php echo wp_json_encode(array('ajax_url' => admin_url('admin-ajax.php'))); ?>;
script>
<script src="php echo get_template_directory_uri(); ?>/self-innovate/page-links.js" defer>script>

php get_footer(); ?>

下面是核心代码的css样式

/**
 *  * page-links.css
 *   * 版本：1.0.0
 *    * 描述：友情链接页面专用样式
 *     * 作者：Eucalyptus
 *      * 创建日期：2025-08-30
 *       * 修改记录：
 *        *   - 2025-08-30：首版，含友链卡片、搜索、弹窗
 *         */

/* ========= 1. 页面通用 ========= */
.page-links{
  max-width:960px;
  margin:0 auto;
  padding:40px 20px;
  font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif;
}

/* ============ 顶部标题（跟随深浅 + 移动端适配） ============ */
/* 友情链接横幅 */
.hero-title{
  padding:3.5rem 1.5rem 2.5rem;
  border-radius:0 0 1.5rem 1.5rem;
  text-align:center;
}
.hero-title h1{
  font-size:2.2rem;
  font-weight:700;
  letter-spacing:.5px;
  position:relative;
}
.hero-title h1::after{
  content:'';
  display:block;
  width:60px;
  height:3px;
  background:#667eea;
  margin:8px auto 0;
  border-radius:2px;
}
.hero-sub{
  font-size:1rem;
  color:#666;
  margin-top:.75rem;
}


/* ========= 玻璃态卡片 3.0 ========= */
.links{
  display:grid;
  grid-template-columns:repeat(3, 1fr); /* 固定 3 列 */
  gap:24px;
}

.link-card{
  position:relative;
  padding:20px;
  background:transparent;                /* 跟随深浅 */
  border:1px solid rgba(var(--color-border,0 0 0),.1);
  border-radius:20px;
  box-shadow:0 8px 32px rgba(0,0,0,.08);  /* 深浅通用阴影 */
  transition:.4s cubic-bezier(.175,.885,.32,1.275);
  overflow:hidden;
}

:root{
  --color-border: 0 0 0;       /* 深色模式 */
}
[data-theme="light"]{
  --color-border: 255 255 255; /* 浅色模式 */
}

.link-card::before{                               /* 光泽渐变 */
  content:'';
  position:absolute;
  inset:0;
  background:linear-gradient(135deg,transparent 40%,rgba(255,255,255,.3));
  pointer-events:none;
}

.link-card:hover{
  transform:translateY(-6px) scale(1.02);
  box-shadow:0 12px 48px rgba(102,126,234,.25);
}

/* 头像 */
.link-card img{
  width:64px;
  height:64px;
  border-radius:50%;
  border:2px solid #fff;
  box-shadow:0 4px 12px rgba(0,0,0,.08);
  object-fit:cover;
}

/* 文字区 */
.link-card .info{
  margin-left:16px;
}
.link-card .name{
  font-size:18px;
  font-weight:700;
  letter-spacing:.5px;
  margin-bottom:6px;
}
.link-card .desc{
  font-size:14px;
  color:#555;
  line-height:1.5;
}

/* 右上角角标（纯 CSS） */
.link-card{
  position: relative;           /* 为伪元素定位 */
}
.link-card::after{
  content: "友链";              /* 角标文字 */
  position: absolute;
  top: 8px;
  right: 8px;
  padding: 2px 6px;
  font-size: 11px;
  font-weight: 600;
  color: #fff;
  background: linear-gradient(135deg,#ea66d4,#ac5196);
  border-radius: 4px;
  opacity: 0;
  transition: opacity .3s;
  pointer-events: none;         /* 不影响点击 */
}
.link-card:hover::after{
  opacity: 1;
}

/* ===== 分类标题 3.0 ===== */
.link-cat{
  position:relative;
  margin-bottom:40px;
}
.link-cat h2{
  display:inline-flex;
  align-items:center;
  gap:8px;
  padding:8px 18px;
  font-size:20px;
  margin-bottom: 15px;
  font-weight:700;
  color:#fff;
  background:linear-gradient(135deg,#667eea,#764ba2);
  border-radius:20px;
  box-shadow:0 4px 12px rgba(102,126,234,.25);
  letter-spacing:.5px;
}

/* 分类描述 */
.link-cat-desc{
  margin: -8px 0 24px 18px;   /* 负值贴紧标题，左侧与标题文字对齐 */
  font-size: 0.9rem;
  color: #555;
  letter-spacing: .4px;
  line-height: 1.5;
  max-width: 540px;
}

/* ========= 移动端适配 ========= */
@media (max-width: 768px) {
  .links {
    grid-template-columns: 1fr; /* 1 列 */
    gap: 20px;
  }

  .link-card {
    padding: 16px;
  }

  .link-card img {
    width: 48px;
    height: 48px;
  }

  .link-card .name {
    font-size: 16px;
  }

  .link-card .desc {
    font-size: 13px;
  }
}
/* ========= 4. 搜索框 ========= */
.link-search{
  display:flex;
  margin-bottom:40px;
}

.link-search input{
  width:100%;
  max-width:320px;
  padding:12px 40px 12px 16px;
  font-size:15px;
  color:#333;
  background:#fff;
  border:2px solid transparent;
  border-radius:30px;
  box-shadow:0 4px 12px rgba(102,126,234,.15);
  transition:border-color .3s, box-shadow .3s;
  outline:none;
  background-image:url('data:image/svg+xml;utf8,');
  background-repeat:no-repeat;
  background-position:right 14px center;
  background-size:20px 20px;
}

/* 悬浮/聚焦高亮 */
.link-search input:focus{
  border-color:#667eea;
  box-shadow:0 0 0 4px rgba(102,126,234,.25);
}

/* placeholder 样式 */
.link-search input::placeholder{
  color:#7f8c8d;
  font-size:14px;
}

/* ========= 5. 按钮 & 弹窗 ========= */
/* 5.1 触发按钮居中容器 */
.btn-center{
  display:flex;
  justify-content:center;
  margin:30px 0;
}

/* 5.2 主按钮样式 */
.btn-hero{
  position:relative;
  padding:12px 32px;
  font-size:16px;
  font-weight:600;
  color:#fff;
  background:linear-gradient(135deg,#667eea 0%, #764ba2 100%);
  border:none;
  border-radius:30px;
  cursor:pointer;
  box-shadow:0 6px 20px rgba(102,126,234,.4);
  transition:all .3s;
  overflow:hidden;
}
.btn-hero:hover{
  transform:translateY(-3px) scale(1.03);
  box-shadow:0 10px 30px rgba(102,126,234,.55);
}

/* 5.3 弹窗遮罩 */
.modal-fade{
  position:fixed;
  inset:0;
  display:flex;
  align-items:center;
  justify-content:center;
  background:rgba(0,0,0,.55);
  backdrop-filter:blur(4px);
  opacity:0;
  visibility:hidden;
  transition:.35s;
  z-index:9999;
}
.modal-fade.show{
  opacity:1;
  visibility:visible;
}

/* 5.4 弹窗主体 */
.modal-dialog{
  width:92%;
  max-width:420px;
  background:#fff;
  border-radius:16px;
  padding:32px 36px 36px;
  position:relative;
  transform:translateY(-30px) scale(.95);
  transition:transform .35s;
}
.modal-fade.show .modal-dialog{
  transform:none;
}

/* 5.5 关闭按钮 */
.modal-close{
  position:absolute;
  top:14px;
  right:18px;
  font-size:26px;
  background:none;
  border:none;
  color:#999;
  cursor:pointer;
}

/* 5.6 表单元素 */
.modal-form{
  display:flex;
  flex-direction:column;
  gap:14px;
}
.modal-form input,
.modal-form textarea{
  padding:12px 14px;
  border:1px solid #e1e5e9;
  border-radius:8px;
}
.btn-submit{
  margin-top:8px;
  padding:12px;
  color:#fff;
  border:none;
  border-radius:30px;
  background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);
  cursor:pointer;
}

/* 移动端补丁，溢出锁死 */
.page-links{
  overflow-x: hidden;   /* 关键：禁止横向滚动 */
}

以下是JavaScript代码，主要用来实现前端友链页面的实时搜索功能、友链提交弹窗（使用模态框组件展示表单，包含必填字段验证和样式反馈）以及后端提交申请内容到后端的功能

/* ========= 实时搜索 ========= */
document.getElementById('link-search').addEventListener('input', function () {
  const kw = this.value.toLowerCase();
  document.querySelectorAll('.link-card').forEach(card => {
    card.style.display = card.textContent.toLowerCase().includes(kw) ? 'flex' : 'none';
  });
});

/* ========= 弹窗控制 ========= */
const overlay = document.getElementById('link-modal-overlay');
document.getElementById('open-link-modal').addEventListener('click', () => overlay.classList.add('show'));
overlay.addEventListener('click', e => {
  if (e.target === overlay || e.target.classList.contains('modal-close')) overlay.classList.remove('show');
});

/* ========= Ajax 提交友链 ========= */
document.getElementById('link-form').addEventListener('submit', function (e) {
  e.preventDefault();
  const data = new FormData(this);
  data.append('action', 'submit_link_apply');
  fetch(ajax_comment_obj.ajax_url, { method: 'POST', body: data })
    .then(r => r.json())
    .then(res => {
      document.getElementById('form-msg').textContent = res.data;
      if (res.success) {
        this.reset();
        setTimeout(() => overlay.classList.remove('show'), 1500);
      }
    });
});

最后是后端处理前端请求并为link_manager新增待审核列的代码，审核逻辑基于链接是否在前端隐藏，关闭私密功能即可前端展示


/**
 * 待审核友链提示
 * 包含：后台列表新增“待审核”列 + 红色气泡菜单提示 + Ajax 接收
 */

/* --------------------------------------------------
 * 1. 后台列表新增“待审核”列，纯文本，系统默认样式
 * -------------------------------------------------- */
/* 新增“待审核”列（键名 review） */
add_filter( 'manage_link-manager_columns', function ( $cols ) {
    $cols['review'] = '待审核';
    return $cols;
} );

/* 单元格输出红色气泡 */
add_action( 'manage_link_custom_column', function ( $col, $link_id ) {
    if ( $col === 'review' ) {
        echo get_bookmark_field( 'link_visible', $link_id ) === 'N'
            ? '待审'
            : '';
    }
}, 10, 2 );


/* --------------------------------------------------
 * 2. 后台“链接”菜单右上角红色数字气泡
 * -------------------------------------------------- */
add_action( 'admin_menu', function () {
    $count = 0;
    foreach ( get_bookmarks( [ 'hide_invisible' => 0 ] ) as $link ) {
        if ( $link->link_visible === 'N' ) $count++;
    }
    if ( $count ) {
        global $menu;
        foreach ( $menu as &$item ) {
            if ( $item[2] === 'link-manager.php' ) {
                $item[0] .= ' ' . $count . '';
                break;
            }
        }
    }
} );

/* --------------------------------------------------
 * 3. Ajax 接收端（无邮件）
 * -------------------------------------------------- */
add_action( 'wp_ajax_nopriv_submit_link_apply', 'handle_link_apply' );
add_action( 'wp_ajax_submit_link_apply',        'handle_link_apply' );
function handle_link_apply() {
    $name  = sanitize_text_field( $_POST['link_name'] ?? '' );
    $url   = esc_url_raw        ( $_POST['link_url']  ?? '' );
    $email = sanitize_email      ( $_POST['link_owner_email'] ?? '' );
    $desc  = sanitize_text_field( $_POST['link_description'] ?? '' );
    $img   = esc_url_raw        ( $_POST['link_image']       ?? '' );

    if ( empty( $name ) || empty( $url ) || ! is_email( $email ) ) {
        wp_send_json_error( '请完整填写必填项' );
    }

    wp_insert_link( [
        'link_name'        => $name,
        'link_url'         => $url,
        'link_description' => $desc,
        'link_image'       => $img,
        'link_owner_email' => $email,
        'link_visible'     => 'N',
    ] );

    wp_send_json_success( '已收到申请，审核后显示，感谢！' );
}

上传代码至20250831主题目录完成部署，最后在functions.php中启用link_manager并调用pending-links.php处理后台任务。

WordPress的functions.php文件中添加指定代码可实现特定功能，需注意代码正确性和备份以防出错。

/* 开启后台链接 */
add_filter( 'pre_option_link_manager_enabled', '__return_true' );

 /* 后台新增友链提示功能 */
require_once get_theme_file_path( '/self-innovate/pending-links.php' );

展示地址：https://images.mingliangstar.com/%e5%8f%8b%e9%93%be/

MySQL8.0.14 双密码机制

Wed, 06 Aug 2025 05:59:03 GMT

MySQL 8.0 引入了双密码策略，这是一种增强安全性的机制。双密码策略允许为每个用户设置两个密码：主密码和次级密码。主密码用于日常操作数据库，而次级密码则用于紧急情况下的访问，有效防止了密码泄露和未授权访问。

双密码机制使得大规模数据库密码轮换变得更平滑，而无需任何的停机时间。在 MySQL 8.0.14 版本之前，更换密码通常会遇到服务不可用时间的问题。而从_** MySQL 8.0.14**_ 起，开始支持了双密码策略。在密码更换时，可以保留旧密码依旧可用。

在更改密码时，首先通过 RETAIN CURRENT PASSWORD 子句设置新的主密码，并保留当前密码作为辅助密码。此时，客户端可以继续使用旧密码（辅助密码）连接数据库，同时新密码（主密码）也已经生效。当新密码已经在所有服务器上同步，且所有应用程序也更新为使用新密码时，可以使用 DISCARD OLD PASSWORD 子句来丢弃辅助密码（原密码），使得数据库仅接受主密码（新密码）。

这种机制特别适用于复杂的系统，尤其是涉及大量 MySQL 实例、复制、多个应用程序连接以及频繁的密码更新时，能够保持服务不中断，从而实现更流畅的密码更改流程。

语法

#创建'demo7'@'%'用户设置密码123456
create user 'demo7'@'%' identified by '123456';
#更新'demo7'@'%'的密码为1234567并保留旧密码123456
ALTER USER 'demo7'@'%' IDENTIFIED BY '1234567' RETAIN CURRENT PASSWORD;
#丢弃旧密码
alter user 'demo7'@'%'  DISCARD OLD PASSWORD;

注意事项

MySQL 8.0.14 起，开始支持了双密码策略，之前并不支持

8.0.13

8.0.14

Centos7下安装Docker

Thu, 31 Jul 2025 06:38:22 GMT

百科说：Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口。

看起来有点雾，用过虚拟机的应该对虚拟化技术有点印象，不知道也没关系，就把它当成轻量级的虚拟机吧（虽然一个是完全虚拟化，一个是操作系统层虚拟化）

百科又说：Docker 使用客户端-服务器 (C/S) 架构模式使用远程API来管理和创建Docker容器。Docker 容器（Container）通过 Docker 镜像（Image）来创建，二者之间的关系类似于面向对象编程中的对象与类

那Docker由什么组成呢，包括三个基本概念:

仓库（Repository）
镜像（Image）
容器(Container）
打个比方：你如果想玩英雄联盟中骚气的亚索，你首先得有这个英雄（Docker的镜像），然后你得花金币去英雄商店（Docker的仓库）买，接着进游戏就会看到一个半蹲的发型飘逸的剑客（Docker的容器），所以：

其中Registry是Docker用于存放镜像文件的仓库，Docker 仓库的概念跟Git 类似（就像商店存放所有的英雄，只是更改英雄的权限在某些非程序员手里）。

所谓镜像就是构建容器的源代码，是一个只读的模板，由一层一层的文件系统组成的，类似于虚拟机的镜像（英雄也是只读的，有自己的技能被动，你也不能进行操作）。

那么容器就是由Docker镜像创建的运行实例，类似于虚拟机，容器之间是相互隔离的，包含特定的应用及其所需的依赖文件（好比每个英雄都是隔离的，都有自己的皮肤，技能以及走的路线)。

注：Docker Hub是Docker公司提供的一个注册服务器（Register）来保存多个仓库，每个仓库又可以包含多个具备不同tag的镜像。

安装 Docker

1.开启linux内核流量转发

cat > /etc/sysctl.d/docker.conf <
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.conf.default.rp_filter = 0
net.ipv4.conf.all.rp_filter = 0
net.ipv4.ip_forward=1
EOF

modprobe br_netfilter

sysctl -p /etc/sysctl.d/docker.conf

2.布置yum仓库，阿里云自带仓库2.阿里云提供的docker专属repo仓库

1 2	curl -o /etc/yum.repos.d/docker-ce.repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo curl /etc/yum.repos.d/Centos-7.repo http://mirrors.aliyun.com/repo/Centos-7.repo

3.更新yum缓存

1	yum clean all && yum makecache

4.查看源中可用的版本

1	yum list docker-ce –showduplicates \| sort -r

5.安装docker-ce

1 2	#这里的版本可以随意选择 yum install -y docker-ce-20.16.7 -y

6.配置docker加速器

使用docker首要操作就是获取镜像文件，默认下载是从Docker Hub下载，网速较慢，国内很多云服务商都提供了加速器服务，阿里云加速器，Daocloud加速器，灵雀云加速器。

先创建一个目录存储加速器

1	mkdir -p /etc/docker

配置加速器文件

vim /etc/docker/daemon.json

{
        "registry-mirrors": [
        "https://ghcr.geekery.cn",
        "https://hub.geekery.cn",
        "https://docker.m.daocloud.io",
        "https://docker.rainbond.cc",
        "https://docker.ckyl.me",
        "https://docker.1panelproxy.com",
        "https://2a6bf1988cb6428c877f723ec7530dbc.mirror.swr.myhuaweicloud.com",
        "https://docker.m.daocloud.io",
        "https://hub-mirror.c.163.com",
        "https://mirror.baidubce.com",
        "https://your_preferred_mirror",
        "https://dockerhub.icu",
        "https://docker.registry.cyou",
        "https://docker-cf.registry.cyou",
        "https://dockercf.jsdelivr.fyi",
        "https://docker.jsdelivr.fyi",
        "https://dockertest.jsdelivr.fyi",
        "https://mirror.aliyuncs.com",
        "https://dockerproxy.com",
        "https://mirror.baidubce.com",
        "https://docker.nju.edu.cn",
        "https://docker.mirrors.sjtug.sjtu.edu.cn",
        "https://docker.mirrors.ustc.edu.cn",
        "https://mirror.iscas.ac.cn"
    ]
}

7.启动docker

使刚才配置的加速器生效

1	systemctl daemon-reload

设置开机自启动

1	systemctl enable docker

启动

1	systemctl start docke

8.检验docker是否安装并成功启动

查看进程

1	ps -ef \| grep docker

查看详细信息

1	docker version

MySQL Innodb Cluster配置

Tue, 22 Jul 2025 07:24:26 GMT

配置规划

本篇文章中MySQL服务采用编译安装，

ip地址	主机名	角色	安装软件
192.168.3.2	348aeb8077a8	主（初始化）	Mysql8.0.30 mysql-shell mysql-route
192.168.3.2	7ff037fcf001	备（初始化）	Mysql8.0.30 mysql-shell mysql-route
192.168.3.4	fc7b8078d23b	备（初始化）	Mysql8.0.30 mysql-shell mysql-route

三台主机分别创建‘mingliang‘@’%’ 用户并授权

1 2	create user 'mingliang'@'%' identified with mysql_native_password by '123456'; grant all on . to 'mingliang'@'%' with grant option;

安装mysql shell（三台机器必须全部安装）

1
2
3

tar -xzvf mysql-shell-8.0.30-linux-glibc2.12-x86-64bit.tar.gz
mv mysql-shell-8.0.30-linux-glibc2.12-x86-64bit /usr/local/mysqlsh
chown mysql8:mysql8 -R /usr/local/mysqlsh

在mysql8用户中配置环境变量

su - mysql8
vim .bash_profile  /添加下述内容

export PATH=$MYSQL_HOME/bin:/usr/local/mysqlsh/bin:$PATH

#使文件生效
source .bash_profile

使用mysql shell登录测试

1	mysqlsh --mysqlx -h 192.168.3.2 -P 33060 -umingliang -p

这里登录测试的时候出现了一个这样的错误
MySQL Error 2027: Requested session assumes MySQL X Protocol but ‘192.168.3.2:3306’ seems to speak the classic MySQL protocol (Unexpected response received from server, msg-id:10)
这个是因为上面连接的时候X协议的端口没有指定正确，可以使用mysql -u root -p -e “select @@mysqlx_port”查看X协议端口，然后连接的时候指定正确的端口就可以成功登录了
参考文档：https://stackoverflow.org.cn/questions/64326446

安装mysql router（三台主机必须全部安装）

tar -xvf mysql-router-8.0.30-linux-glibc2.12-x86_64.tar.xz

#没有xz的话需要安装下
yum install -y xz

mv mysql-router-8.0.30-linux-glibc2.12-x86_64 /usr/local/mysqlrouter
chown mysql8:mysql8 /usr/local/mysqlrouter

在MySQL8用户中配置环境变量

su - mysql8
vim .bash_profile  /添加下述内容

export PATH=$MYSQL_HOME/bin:/usr/local/mysqlsh/bin:/usr/local/mysqlrouter/bin:$PATH

#使文件生效
source .bash_profile

通过MySQLShell搭建MGR，下面步骤每个节点都执行

#192.168.3.2 root@348aeb8077a8  master
su - mysql8
mysqlsh --mysqlx -h 192.168.3.2 -P33060 -umingliang -p
  dba.configureInstance();
  dba.configureInstance();

#192.168.3.3 root@7ff037fcf001  slave1
su - mysql8
mysqlsh --mysqlx -h 192.168.3.3 -P33060 -umingliang -p
  dba.configureInstance();
  dba.configureInstance();

#192.168.3.4 root@fc7b8078d23b  slave2
su - mysql8
mysqlsh --mysqlx -h 192.168.3.4 -P33060 -umingliang -p
  dba.configureInstance();
  dba.configureInstance();

创建集群实例（在master执行即可）

#默认为单主模式，第一个加入为写节点
#---第一个节点创建集群实例(192.168.3.2)

  var cluster = dba.createCluster('DemoCluster')

#添加其他节点192.168.3.3和192.168.3.3，此时会进行数据库克隆，
#把节点1的数据库复制到其它数据库，同时进行同步。

  var cluster=dba.getCluster()
  cluster.addInstance('mingliang@192.168.3.3:3306')
  cluster.addInstance('mingliang@192.168.3.4:3306')

#查看集群状态
  var cluster=dba.getCluster()
  cluster.status();

这里由于3个节点的UUID相同导致，添加集群节点的没有添加进去
Cluster.addInstance: Cannot add an instance with the same server UUID (1d6dd7c2-5ff7-11f0-bb22-0242c0a80302) of an active member of the cluster ‘348aeb8077a8:3306’. Please change the UUID of the instance to add, all members must have a unique server UUID. (RuntimeError)
更新uuid后，master节点执行了克隆恢复，但是发现一直处于* Waiting for server restart… 状态，直至超时，去slave查看error.log发现发生了crash，导致启动失败
最后重新配置了一次，在添加节点恢复的时候选择了增量恢复后，成功添加
#添加slave1
#添加slave2

配置MySQLRouter路由

#创建路由文件
su - mysql8
mkdir myroyter


#路由初始化
#master
mysqlrouter --bootstrap mingliang@172.0.0.1:3306 --directory /home/mysql8/myrouter --conf-use-sockets  --user mysql8

#启动路由
.myrouter/star.sh

测试配置

连接测试

1	mysql -u mingliang -p -P6446

数据同步测试

1	create database demo1;

故障测试

主备切换

1	cluster.setPrimaryInstance('192.168.3.2:3306')

关闭集群

1
2
3

#先关闭2个从节点，然后在关闭主节点

#Mgr无需单独关闭，单主备库都关闭时，其进程自动关闭

重启集群

#先启动2个从节点，然后再启动主节点

#启动mgr
  dba.rebootClusterFromCompleteOutage()

MySQL Innodb Cluster介绍

Mon, 14 Jul 2025 08:52:52 GMT

MySQL InnoDB Cluster 是 MySQL 官方提供的高可用性解决方案，它结合了 MySQL Shell、MySQL Server 和 Group Replication 技术，使您能够部署和管理完整的集成高可用性解决方案。

https://dev.mysql.com/doc/refman/8.0/en/mysql-innodb-cluster-introduction.html

以下是对 MySQL InnoDB Cluster 的详细介绍：

核心组件

MySQL Shell：MySQL Shell 是一个现代化的命令行客户端，提供对 MySQL Server 的强大交互式访问，支持 JavaScript 和 Python 两种编程语言接口。在 InnoDB Cluster 环境中，MySQL Shell 充当了管理和监控集群的控制台工具，内置了 AdminAPI，用于简化群的创建、配置、扩展、维护等操作。
MySQL Router：MySQL Router 是轻量级的服务代理，用于透明地路由客户端请求到正确的 MySQL 服务器实例。根据集的部署信息，MySQL Router 能自动生成合适的配置，确保客户端应用无需关心后端服务器的细节，即可无缝连接到群中的主节点（在单主模式下）或读写节点（在多主模式下），并根据集状态自动调整路由策略。
MySQL Server 和 Group Replication：使一组 MySQL 实例能够提供高可用性。InnoDB Cluster 提供了一种替代的、易于使用的编程方式来使用组复制。

核心原理与优势

InnoDB Cluster 基于 MySQL Group Replication 构建，提供自动成员管理、容错、自动故障转移等功能。InnoDB Cluster 通常以单主模式运行，有一个主实例（读写）和多个辅助实例（只读）。高级用户还可以利用多主模式，其中所有实例都是主实例。您甚至可以在 InnoDB Cluster 在线时更改集的拓扑结构，以确保尽可能高的可用性。

与经典主从复制的比较

经典的主从复制是 MySQL 原生的复制功能，采用异步方式。主服务器执行更改数据的事务后，会产生 binlog，之后 binlog 会被发送到从服务器变成 relay log。与此同时，主服务器会对提交返回。从服务器接收到 relay log 后，会通过一个 applier 的线程对日志里面的内容进行施放，使产生的数据更改写入从服务器，之后产生自己的 binlog，进行提交。

与经典的主从复制相比，InnoDB Cluster 基于组复制，提供了更高的可用性。在 InnoDB Cluster 中，每个 MySQL 服务器实例都是组复制的成员，数据在集群内的同步更加可靠。此外，InnoDB Cluster 还提供了自动故障转移功能，能够在某个实例出现故障时自动将任务转移到其他实例上，避免了手动介入和业务中断。

总结

InnoDB Cluster 作为一种新兴的数据库解决方案，通过提供自动故障转移、易于管理的 API 和路由等功能，为企业提供了高可用性的数据库服务。在实际应用中，通过合理的配置和管理，InnoDB Cluster 能够确保业务的连续性和数据的可靠性。随着技术的发展和业务的不断扩展，InnoDB Cluster 将成为越来越多企业的首选数据库解决方案。

WPCode添加代码启用后网站报错怎么处理

Sat, 31 May 2025 13:25:07 GMT

有时候我们使用WPCode插件添加的代码可能会出现问题，或者与其他代码产生冲突，这就可能导致网站出现报错的情况。

这种时候通常可以采取两种不同的应对方式：

一、修改文件

如果在添加代码后网站出现报错，可以尝试通过登录后台服务器或者使用FTP删除或重命名 WPCode 插件的文件夹，这个文件夹的名称通常是 “insert-headers-and-footers”，操作前建议先备份相关数据，以确保网站的安全。

1 2	#重命名 mv insert-headers-and-footers insert-headers-and-footers-mv

其实不建议使用这种方法，如果你是把代码添加到了functions.php文件中，可以直接编辑并删除。但这种情况涉及的是插件，使用的是WPCode插件，一旦你重新启用它，之前添加的代码又会被载入并保持开启状态，这样一来，你网站上的报错问题还会再次出现。

二、进入WPCode插件的安全模式

在网站域名后面加上 /wp-admin/?wpcode-safe-mode=1 即可进入安全模式，例如：

1	https://mingliang.net.cn//wp-admin/?wpcode-safe-mode=1

进入安全模式后可以看到网站将不再执行 WPCode 插件所添加的任何代码。

这时你可以在后台的WPCode插件中找到刚刚添加并导致错误的代码片段，直接删除或禁用，以恢复正常运行。

WordPress通过简码插入bilibili视频

Tue, 25 Mar 2025 15:24:09 GMT

一、前言

B站是国内非常受欢迎的视频分享平台，上面不仅内容丰富，而且很多视频制作精良、趣味十足。很多人，比如我，就喜欢将B站的视频通过 iframe 嵌入到自己的网页中，但这段代码又长又复杂，字符长度大约有230个，每次使用都很麻烦。为了让大家更方便地在 WordPress 网站中插入B站视频，我准备了一个简单实用的短代码教程，轻松几步就能搞定。

二、代码

将以下代码复制到网站主题的 functions.php 文件末尾即可完成添加。

/**
 * 添加插入Bilibili视频的短代码
 *
 * @param array $atts 短代码属性数组
 * @param string|null $content 短代码内容（未使用）
 * @return string 返回生成的HTML代码
 */
function vbilibili_shortcode( $atts, $content = null ) {
    // 默认参数值
    $defaults = array(
        'av' => '',    // Bilibili视频的AV号
        'bv' => '',    // Bilibili视频的BV号
        'w'  => '100%', // 默认宽度为100%
    );

    // 解析短代码中的参数
    $atts = shortcode_atts( $defaults, $atts );
    
    // 如果参数 av 和 bv 都为空，则返回错误信息
    if ( empty( $atts['av'] ) && empty( $atts['bv'] ) ) {
        return 'av 和 bv 不可为空
';
    }

    // 如果参数 av 和 bv 同时存在，则返回错误信息
    if ( ! empty( $atts['av'] ) && ! empty( $atts['bv'] ) ) {
        return 'av 和 bv 不可同时存在
';
    }

    // 根据参数 av 或 bv 构建 iframe 的 URL
    if ( ! empty( $atts['av'] ) ) {
        $iframe_url = 'https://player.bilibili.com/player.html?aid=' . esc_attr( $atts['av'] ) . '&high_quality=1';
    } elseif ( ! empty( $atts['bv'] ) ) {
        $iframe_url = 'https://player.bilibili.com/player.html?bvid=' . esc_attr( $atts['bv'] ) . '&high_quality=1';
    }

    // 构建 iframe 的 HTML 代码，并直接应用内联样式
    $iframe = ' . $iframe_url . '" style="position:absolute; top:0; left:0; width:100%; height:100%;" frameborder="no" scrolling="no" allowfullscreen="allowfullscreen">
';

    // 返回 iframe 的 HTML 代码
    return $iframe;
}
add_shortcode( 'vbilibili', 'vbilibili_shortcode' );

将内容嵌入到中，并通过设置相关属性来限制内的页面无法在新窗口或新标签页中打开，从而防止跳转到 B 站。可以通过在标签中添加 sandbox 属性，结合 allow 属性精确控制权限，确保用户在当前页面内浏览，不被引导至其他网站。这种方式有助于提升用户体验的连续性，同时防止意外跳转带来的干扰。

1	sandbox="allow-top-navigation allow-same-origin allow-forms allow-scripts"

三、WPCode

如果你使用的是一个经常更新的主题，每次更新后都需要将代码添加到 functions.php 文件中，这显然十分麻烦。为了解决这个问题，你可以使用 WPCode 插件，在不修改主题文件的情况下，轻松实现自定义代码片段的添加和管理。

3.1、WPCode介绍

WPCode 是一款流行的WordPress插件，它允许用户在不修改主题文件的情况下，向WordPress网站添加自定义代码片段。这款插件非常适合需要在网站中添加额外功能的站长，例如，添加Google分析或百度统计的代码，或者插入自定义CSS、JavaScript等。

WPCode插件还提供了一个代码片段库，您可以在这个库里面找到经过验证的PHP代码片段，例如：禁用REST API、禁用 XML-RPC、禁用注释、允许 SVG 文件上传、禁用 Gutenberg、添加经典编辑器等，而无需为每个请求安装单独的插件。使用这个插件，还可以控制代码的激活状态，如果需要在调试情况下先不适用某个功能，可以先不激活，而不是直接删除。

总之非常方便，如果您的网站也是WordPress网站，那么站长建议您可以安装下这个插件试一试。

3.2、自定义代码到WPCode

3.3、使用简码

1	[vbilibili 参数名="参数值"][/vbilibili]

参数：

参数名	可选值	默认值	解释	是否必须
av	–	–	Bilibili 视频的 AV 号	是
bv	–	–	Bilibili 视频的 BV 号	是

示例：

1	[vbilibili bv=BV1SoZ5YVEJg][/vbilibili]

注意：

Bilibili 视频的 AV 号或 BV 号是必须的，但只要输入 AV 号或 BV 号的其中一个即可。
Bilibili 视频的 AV 号不要带上 av

Wordpress登录页面插件

Fri, 03 Jan 2025 03:36:28 GMT

一、前言

20250103 | wp-login Custom Login Page Customizer 是一款WordPress插件，它提供了丰富的自定义字段来改变WordPress登录页面的布局。使用该插件，您可以完全修改登录页面的外观和感觉，包括登录错误消息、忘记密码错误消息、注册错误消息、忘记密码提示消息等。20250103 插件使用 Customizer API 构建，允许您实时预览登录页面的更改。该插件非常易于使用，不需要任何编码技能，只需为登录表单的每个元素设置选项，就可以在几秒钟内创建一个新的自定义登录页面。

20250103 提供了免费和专业版插件，专业版提供了更多的功能，如Google字体、Google reCaptcha、选择主题等。如果您希望为您的WordPress网站添加一个外观酷炫的登录页面，20250103 是一个必备的插件。

二、20250103功能

Logo：可以更改登录Logo {image，width，height，padding，URL and Title}。
背景：您可以自定义背景图像或颜色。设置其位置、大小和可重复属性。
登录表单：即使你可以自定义登录表单{图像或颜色，宽度，高度，填充和边框}。自定义输入文本字段{宽度，边距，文本颜色，标签颜色和背景颜色}。
忘记形式：美丽的插件在这里你可以改变背景或颜色的忘记形式。
按钮：您可以设置按钮所见即所得的颜色。
错误消息：插件的主要功能.您可以更改错误日志消息，因为您希望在20250103→ Error Messages中向用户显示。
欢迎消息：与错误日志消息相同，您可以通过20250103→ Welcome Messages自定义欢迎消息。
表单页脚：登录按钮后，这里是表单页脚.您可以自定义页脚{文本、显示、文本装饰、文本颜色、文本悬停颜色和文本大小}。在此部分中，您还可以自定义页脚文本。

定制后使WordPress登录页面移动的友好
这个插件也是响应式的。这意味着，当您自定义登录页面，它会在移动的上看起来不错，即它是响应式的.

三、演示

使用reCAPTCHA和Google Fonts需要购买20250103Pro版，而系统中其他所有工具和服务均可免费使用。无论是进行基础的表单验证、网站数据分析，还是应用多样化的字体样式，平台都为用户提供了全面支持，让在线项目的创建和管理更加高效便捷。

20250103默认主题

20250103ProPro主题

四、20250103Pro百度网盘下载

为了确保功能完整使用，建议将20250103与其付费升级版本20250103Pro一并安装，这样可以充分发挥其全部潜力并提升用户体验。

百度网盘地址：https://pan.baidu.com/s/1gm3aBamBy7o9_7bRZ_WcZg?pwd=xqqn
提取码：xqqn

轻博客的粒子浪漫

Fri, 13 Dec 2024 02:50:50 GMT

一、鼠标点击烟花特效

鸣谢：https://juejin.cn/post/7106018120036253710#heading-2

<html>
<body>
<script>
function clickEffect() {
  let balls = [];
  let longPressed = false;
  let longPress;
  let multiplier = 0;
  let width, height;
  let origin;
  let normal;
  let ctx;
  const colours = ["#F73859", "#14FFEC", "#00E0FF", "#FF99FE", "#FAF15D"];
  const canvas = document.createElement("canvas");
  document.body.appendChild(canvas);
  canvas.setAttribute("style", "width: 100%; height: 100%; top: 0; left: 0; z-index: 99999; position: fixed; pointer-events: none;");
  const pointer = document.createElement("span");
  pointer.classList.add("pointer");
  document.body.appendChild(pointer);
 
  if (canvas.getContext && window.addEventListener) {
    ctx = canvas.getContext("2d");
    updateSize();
    window.addEventListener('resize', updateSize, false);
    loop();
    window.addEventListener("mousedown", function(e) {
      pushBalls(randBetween(10, 20), e.clientX, e.clientY);
      document.body.classList.add("is-pressed");
      longPress = setTimeout(function(){
        document.body.classList.add("is-longpress");
        longPressed = true;
      }, 500);
    }, false);
    window.addEventListener("mouseup", function(e) {
      clearInterval(longPress);
      if (longPressed == true) {
        document.body.classList.remove("is-longpress");
        pushBalls(randBetween(50 + Math.ceil(multiplier), 100 + Math.ceil(multiplier)), e.clientX, e.clientY);
        longPressed = false;
      }
      document.body.classList.remove("is-pressed");
    }, false);
    window.addEventListener("mousemove", function(e) {
      let x = e.clientX;
      let y = e.clientY;
      pointer.style.top = y + "px";
      pointer.style.left = x + "px";
    }, false);
  } else {
    console.log("canvas or addEventListener is unsupported!");
  }
 
 
  function updateSize() {
    canvas.width = window.innerWidth * 2;
    canvas.height = window.innerHeight * 2;
    canvas.style.width = window.innerWidth + 'px';
    canvas.style.height = window.innerHeight + 'px';
    ctx.scale(2, 2);
    width = (canvas.width = window.innerWidth);
    height = (canvas.height = window.innerHeight);
    origin = {
      x: width / 2,
      y: height / 2
    };
    normal = {
      x: width / 2,
      y: height / 2
    };
  }
  class Ball {
    constructor(x = origin.x, y = origin.y) {
      this.x = x;
      this.y = y;
      this.angle = Math.PI * 2 * Math.random();
      if (longPressed == true) {
        this.multiplier = randBetween(14 + multiplier, 15 + multiplier);
      } else {
        this.multiplier = randBetween(6, 12);
      }
      this.vx = (this.multiplier + Math.random() * 0.5) * Math.cos(this.angle);
      this.vy = (this.multiplier + Math.random() * 0.5) * Math.sin(this.angle);
      this.r = randBetween(8, 12) + 3 * Math.random();
      this.color = colours[Math.floor(Math.random() * colours.length)];
    }
    update() {
      this.x += this.vx - normal.x;
      this.y += this.vy - normal.y;
      normal.x = -2 / window.innerWidth * Math.sin(this.angle);
      normal.y = -2 / window.innerHeight * Math.cos(this.angle);
      this.r -= 0.3;
      this.vx *= 0.9;
      this.vy *= 0.9;
    }
  }
 
  function pushBalls(count = 1, x = origin.x, y = origin.y) {
    for (let i = 0; i < count; i++) {
      balls.push(new Ball(x, y));
    }
  }
 
  function randBetween(min, max) {
    return Math.floor(Math.random() * max) + min;
  }
 
  function loop() {
    ctx.fillStyle = "rgba(255, 255, 255, 0)";
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    for (let i = 0; i < balls.length; i++) {
      let b = balls[i];
      if (b.r < 0) continue;
      ctx.fillStyle = b.color;
      ctx.beginPath();
      ctx.arc(b.x, b.y, b.r, 0, Math.PI * 2, false);
      ctx.fill();
      b.update();
    }
    if (longPressed == true) {
      multiplier += 0.2;
    } else if (!longPressed && multiplier >= 0) {
      multiplier -= 0.4;
    }
    removeBall();
    requestAnimationFrame(loop);
  }
 
  function removeBall() {
    for (let i = 0; i < balls.length; i++) {
      let b = balls[i];
      if (b.x + b.r < 0 || b.x - b.r > width || b.y + b.r < 0 || b.y - b.r > height || b.r < 0) {
        balls.splice(i, 1);
      }
    }
  }
}
clickEffect();//调用特效函数
script>
body>
html>

二、鼠标点击爱心特效

html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Documenttitle>
head>
 
<body>
    
    <script type="text/javascript">
         ! function (e, t, a) {
            function r() {
                for (var e = 0; e < s.length; e++) s[e].alpha <= 0 ? (t.body.removeChild(s[e].el), s.splice(e, 1)) : (s[
                        e].y--, s[e].scale += .004, s[e].alpha -= .013, s[e].el.style.cssText = "left:" + s[e].x +
                    "px;top:" + s[e].y + "px;opacity:" + s[e].alpha + ";transform:scale(" + s[e].scale + "," + s[e]
                    .scale + ") rotate(45deg);background:" + s[e].color + ";z-index:99999");
                requestAnimationFrame(r)
            }
 
            function n() {
                var t = "function" == typeof e.onclick && e.onclick;
                e.onclick = function (e) {
                    t && t(), o(e)
                }
            }
 
            function o(e) {
                var a = t.createElement("div");
                a.className = "heart", s.push({
                    el: a,
                    x: e.clientX - 5,
                    y: e.clientY - 5,
                    scale: 1,
                    alpha: 1,
                    color: c()
                }), t.body.appendChild(a)
            }
 
            function i(e) {
                var a = t.createElement("style");
                a.type = "text/css";
                try {
                    a.appendChild(t.createTextNode(e))
                } catch (t) {
                    a.styleSheet.cssText = e
                }
                t.getElementsByTagName("head")[0].appendChild(a)
            }
 
            function c() {
                return "rgb(" + ~~(255 * Math.random()) + "," + ~~(255 * Math.random()) + "," + ~~(255 * Math
                    .random()) + ")"
            }
            var s = [];
            e.requestAnimationFrame = e.requestAnimationFrame || e.webkitRequestAnimationFrame || e
                .mozRequestAnimationFrame || e.oRequestAnimationFrame || e.msRequestAnimationFrame || function (e) {
                    setTimeout(e, 1e3 / 60)
                }, i(
                    ".heart{width: 10px;height: 10px;position: fixed;background: #f00;transform: rotate(45deg);-webkit-transform: rotate(45deg);-moz-transform: rotate(45deg);}.heart:after,.heart:before{content: '';width: inherit;height: inherit;background: inherit;border-radius: 50%;-webkit-border-radius: 50%;-moz-border-radius: 50%;position: fixed;}.heart:after{top: -5px;}.heart:before{left: -5px;}"
                ), n(), r()
        }(window, document);
    script>
body>
 
html>

三、鼠标点击文字特效

html>
<html lang="en">
 
<head>
    <meta charset="UTF-8">
    <title>Documenttitle>
head>
 
<body>
    <script>
        (function () {
            var a_idx = 0;
            window.onclick = function (event) {
                var a = new Array("❤富强❤", "❤民主❤", "❤文明❤", "❤和谐❤", "❤自由❤", "❤平等❤", "❤公正❤", "❤法治❤", "❤爱国❤",
                    "❤敬业❤", "❤诚信❤", "❤友善❤");
 
                var heart = document.createElement("b"); //创建b元素
                heart.onselectstart = new Function('event.returnValue=false'); //防止拖动
 
                document.body.appendChild(heart).innerHTML = a[a_idx]; //将b元素添加到页面上
                a_idx = (a_idx + 1) % a.length;
                heart.style.cssText = "position: fixed;left:-100%;"; //给p元素设置样式
 
                var f = 16, // 字体大小
                    x = event.clientX - f / 2, // 横坐标
                    y = event.clientY - f, // 纵坐标
                    c = randomColor(), // 随机颜色
                    a = 1, // 透明度
                    s = 1.2; // 放大缩小
 
                var timer = setInterval(function () { //添加定时器
                    if (a <= 0) {
                        document.body.removeChild(heart);
                        clearInterval(timer);
                    } else {
                        heart.style.cssText = "font-size:16px;cursor: default;position: fixed;color:" +
                            c + ";left:" + x + "px;top:" + y + "px;opacity:" + a + ";transform:scale(" +
                            s + ");";
 
                        y--;
                        a -= 0.016;
                        s += 0.002;
                    }
                }, 15)
 
            }
            // 随机颜色
            function randomColor() {
 
                return "rgb(" + (~~(Math.random() * 255)) + "," + (~~(Math.random() * 255)) + "," + (~~(Math
                .random() * 255)) + ")";
 
            }
        }());
    script>
body>
 
html>

四、鼠标星星拖尾特效

鸣谢：https://blog.csdn.net/weixin_44461275/article/details/131402453

JS

function drawStar() {
  //定义数组，arr存放每个小星星的信息，colour为颜色数组，存几个好看的颜色
  var arr = [];
  var colours = ["#ffff00", "#66ffff", "#3399ff", "#99ff00", "#ff9900"];
  var timeoutList = []; // 计时器列表-用于后续清理计时器

  // 创建画布
  const canvas = document.createElement('canvas')
  document.body.appendChild(canvas)
  var ctx = canvas.getContext("2d");

  // 让画布自适应窗口大小，这个复制即可
  function resizeCanvas() {
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
  }
  resizeCanvas();

  // 给画布css样式，固定定位，且阻止用户的鼠标事件
  canvas.style.cssText = `
    position: fixed;
    z-index: 1000;
    top: 0;
    left: 0;
    pointer-events: none;
  `;

  // 封装绘制一个五角星函数
  // x是圆心横坐标，y是圆心纵坐标，其实就是鼠标位置（x ，y）
  // r是里面小圆半径 ，l是大圆半径
  // rot是初始旋转角度
  function star(x, y, r, l, rot) {
    ctx.beginPath();
    // 循环5次，因为5个点
    for (let i = 0; i < 5; i++) {
      //先绘制小圆上一个点
      ctx.lineTo(
        Math.cos(((18 + i * 72 - rot) * Math.PI) / 180) * r + x,
        -Math.sin(((18 + i * 72 - rot) * Math.PI) / 180) * r + y
      );
      //连线到大圆上一个点
      ctx.lineTo(
        Math.cos(((54 + i * 72 - rot) * Math.PI) / 180) * l + x,
        -Math.sin(((54 + i * 72 - rot) * Math.PI) / 180) * l + y
      );
    }
    ctx.closePath();
  }

  // 绘制一堆星星
  function draw() {
    //循环数组
    for (let i = 0; i < arr.length; i++) {
      let temp = arr[i];
      //调用绘制一个星星函数
      star(temp.x, temp.y, temp.r, temp.r * 3, temp.rot);
      //星星颜色
      ctx.fillStyle = temp.color;
      //星星边框颜色
      ctx.strokeStyle = temp.color;
      //线宽度
      ctx.lineWidth = 0.1;
      //角有弧度
      ctx.lineJoin = "round";
      // 填充
      ctx.fill();
      // 绘制路径
      ctx.stroke();
    }
  }

  //更新动画
  function update() {
    //循环数组
    for (let i = 0; i < arr.length; i++) {
      // x坐标+dx移动距离
      arr[i].x += arr[i].dx;
      // y坐标+dy移动距离
      arr[i].y += arr[i].dy;
      // 加上旋转角度
      arr[i].rot += arr[i].td;
      // 半径慢慢减小
      arr[i].r -= 0.015;
      // 当半径小于0时
      if (arr[i].r < 0) {
        //删除该星星
        arr.splice(i, 1);
      }
    }
  }

  // 添加当前位置星星数据
  function addStarts(e) {
    // 每移动触发一次事件给arr数组添加一个星星
    arr.push({
      // x是初始横坐标
      x: e.clientX,
      //y是初始纵坐标
      y: e.clientY,
      //r是星星里面那个小圆半径，哪来的小圆等会说
      r: Math.random() * 0.5 + 1.5,
      //运动时旋转的角度
      td: Math.random() * 4 - 2,
      // X轴移动距离
      dx: Math.random() * 2 - 1,
      // y轴移动距离
      dy: Math.random() * 1 + 1,
      // 初始的旋转角度
      rot: Math.random() * 90 + 90,
      // 颜色
      color: colours[Math.floor(Math.random() * colours.length)],
    });
  }

  // 监听屏幕变化事件
  window.onresize = resizeCanvas;

  // 监听鼠标移动事件
  window.addEventListener("mousemove", (e) => {
    // 添加星星数据
    addStarts(e);

    //设置100毫秒内效果
    for (let index = 0; index < 200; index++) {
      if (index === 0 && timeoutList.length > 0) {
        for (const timeoutName of timeoutList) {
          clearTimeout(timeoutName)
        }
      }
      timeoutList[index] = setTimeout(() => {
        //清屏
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        //绘制
        draw();
        //更新
        update();
      }, index * 20);
    }
  });
}

drawStar()

HTML

html>
<html lang="en">

<head>
    
head>

<body>
    <span class="js-cursor-container">span>
    <script>
        (function fairyDustCursor() {

            var possibleColors = ["#D61C59", "#E7D84B", "#1B8798"]
            var width = window.innerWidth;
            var height = window.innerHeight;
            var cursor = { x: width / 2, y: width / 2 };
            var particles = [];

            function init() {
                bindEvents();
                loop();
            }

            // Bind events that are needed
            function bindEvents() {
                document.addEventListener('mousemove', onMouseMove);
                window.addEventListener('resize', onWindowResize);
            }

            function onWindowResize(e) {
                width = window.innerWidth;
                height = window.innerHeight;
            }

            function onMouseMove(e) {
                cursor.x = e.clientX;
                cursor.y = e.clientY;

                addParticle(cursor.x, cursor.y, possibleColors[Math.floor(Math.random() * possibleColors.length)]);
            }

            function addParticle(x, y, color) {
                var particle = new Particle();
                particle.init(x, y, color);
                particles.push(particle);
            }

            function updateParticles() {

                // Updated
                for (var i = 0; i < particles.length; i++) {
                    particles[i].update();
                }

                // Remove dead particles
                for (var i = particles.length - 1; i >= 0; i-) {
                    if (particles[i].lifeSpan < 0) {
                        particles[i].die();
                        particles.splice(i, 1);
                    }
                }

            }

            function loop() {
                requestAnimationFrame(loop);
                updateParticles();
            }

            /**
             * Particles
             */

            function Particle() {

                this.character = "*";
                this.lifeSpan = 120; //ms
                this.initialStyles = {
                    "position": "fixed",
                    "display": "inline-block",
                    "top": "0px",
                    "left": "0px",
                    "pointerEvents": "none",
                    "touch-action": "none",
                    "z-index": "10000000",
                    "fontSize": "25px",
                    "will-change": "transform"
                };

                // Init, and set properties
                this.init = function (x, y, color) {

                    this.velocity = {
                        x: (Math.random() < 0.5 ? -1 : 1) * (Math.random() / 2),
                        y: 1
                    };

                    this.position = { x: x + 10, y: y + 10 };
                    this.initialStyles.color = color;

                    this.element = document.createElement('span');
                    this.element.innerHTML = this.character;
                    applyProperties(this.element, this.initialStyles);
                    this.update();

                    document.querySelector('.js-cursor-container').appendChild(this.element);
                };

                this.update = function () {
                    this.position.x += this.velocity.x;
                    this.position.y += this.velocity.y;
                    this.lifeSpan-;

                    this.element.style.transform = "translate3d(" + this.position.x + "px," + this.position.y + "px, 0) scale(" + (this.lifeSpan / 120) + ")";
                }

                this.die = function () {
                    this.element.parentNode.removeChild(this.element);
                }

            }

            /**
             * Utils
             */

            // Applies css `properties` to an element.
            function applyProperties(target, properties) {
                for (var key in properties) {
                    target.style[key] = properties[key];
                }
            }

            if (!('ontouchstart' in window || navigator.msMaxTouchPoints)) init();
        })();    
    script>
body>

html>

解决容器启动后无法编辑文件的问题

Sat, 07 Sep 2024 14:09:25 GMT

前段时间拉取了个MySQL的容器节点，但是拉起之后发现居然编辑不了MySQL的配置文件，这是我的启动命令

1	docker run -itd -p 3310:3306 -e MYSQL_ROOT_PASSWORD=12345678 --name slave2 f5f171121fa3 bash

下面总结下解决方法：

编辑docker file直接从根本上解决问题（还没试过）
安装需要命令的rpm包（不推荐，依赖特别多）
将需要编辑的文件在宿主机上编辑，然后再传到容器中（不推荐，特麻烦）
直接宿主机的挂载目录中编辑对应的容器文件（还行，比较容易）
我还有个想法，俗话所一切皆文件，直接将需要命令的相关文件从宿主机copy到容器中即可（还没试过）

当然上面的方法比较另辟迄今，当我们遇到没有一个命令时首先想到的应该是安装，但是有的小伙伴也可能又和我遇到了同样的问题，比如，一顿操作猛如虎….

首先启动一个容器后看下启动容器的os信息

1	cat /etc/os-release

可以看到这个MySQL是oracle封装的你使用其他os命令肯定不行，但是我们可能对oracle linux server的命令不是很熟悉，那么该怎么办呢，下面介绍一个比yum,dnf还要轻量级的软件包管理器—microdnf

microdnf 是一个轻量级的包管理器，它是 DNF 的一个分支，专为使用在容器环境和嵌入式系统中而设计。由于容器和嵌入式系统通常有资源限制，包括有限的磁盘空间和内存，microdnf 被优化以减少其内存占用和执行速度。
以下是 microdnf 的一些关键特点：
轻量化：microdnf 旨在减少内存和磁盘的使用，使其适合在资源受限的环境中运行。
兼容性：它与 DNF 高度兼容，支持大部分 DNF 命令和功能，但去掉了一些在容器中不必要的功能。
简单性：microdnf 提供了一个简单的方法来安装、更新和删除软件包。
依赖管理：尽管是轻量级，microdnf 仍然处理依赖关系，确保安装的软件包所依赖的包也得到安装。
配置文件：microdnf 使用 /etc/microdnf.conf 或 /etc/dnf/microdnf.conf 作为其主要配置文件。
仓库管理：它支持配置软件仓库（repositories），允许用户添加、移除或修改仓库的配置。
包管理操作：microdnf 支持基本的包管理操作，如安装、更新、查询和删除软件包。
静默操作：它支持静默模式，可以在不提示用户输入的情况下自动执行操作。
安全性：microdnf 可以配置为自动更新安全相关的包，帮助维护容器的安全性。
使用场景：它适用于容器化应用、嵌入式系统和任何需要轻量级包管理器的场景。
与 DNF 的区别：microdnf 没有 DNF 的所有特性，比如管理插件、复杂的仓库元数据处理等。
命令示例：
_ - 安装包：microdnf install
__- 更新包：microdnf update
__- 查询包：microdnf info
__- 删除包：microdnf remove
_- 列出已安装包：microdnf list --installed
microdnf 是一个实用的工具，尤其适用于需要轻量级包管理的场合。然而，它可能不适合那些需要 DNF 所有高级功能的环境。在使用 microdnf 时，您应该根据您的具体需求和环境来评估其适用性。

用microdnf安装vim

1	microdnf -y install vim

学识浅薄，疏漏难免，祈望高贤不吝赐教。

搭建与配置私有Docker镜像仓库实战指南

Wed, 04 Sep 2024 08:46:46 GMT

前言

在当今快速迭代的软件开发环境中，Docker已成为容器化应用部署的事实标准，极大地提升了应用的可移植性、一致性和开发效率。随着企业级应用对容器技术依赖的日益加深，私有Docker镜像仓库的重要性愈发凸显。它不仅关乎于镜像的安全存储与高效分发，更是实现团队间高效协作与持续集成/持续部署（CI/CD）流程的关键一环。

然而，对于许多开发者和IT管理人员而言，搭建并配置一个稳定、高效且安全的私有Docker镜像仓库仍是一项挑战。从环境准备到服务部署，从访问控制到镜像备份，每一步都需谨慎规划与实施，以确保满足企业的特定需求和合规要求。

《搭建与配置私有Docker镜像仓库实战指南》正是为解决这一需求而生。本文旨在通过详实的步骤说明与实战案例，引导读者从零开始，深入理解私有Docker镜像仓库的核心概念，掌握Harbor、Nexus等主流私有仓库软件的安装、配置与管理技巧。我们不仅会探讨基本的部署策略，还会涉及高级功能如镜像签名、复制策略、性能优化及安全实践，确保您的私有仓库能够稳健运行，为团队带来最大化的效益。

无论您是刚刚接触容器技术的新手，还是寻求提升现有基础设施效能的资深工程师，本指南都将为您提供宝贵的参考与启示。让我们一同开启构建高效、安全私有Docker镜像仓库的旅程，为您的DevOps实践增添强大动力。

关于镜像加速器的配置在之前的文章中已经介绍过了

centos7下安装docker

当然阿里云官方文档中的这个加速器好像没有什么diao用，容器镜像服务 (aliyun.com)

推荐配置：

{
   "registry-mirrors": [
 
  "https://docker.m.daocloud.io",
        "https://dockerproxy.com",
        "https://docker.mirrors.ustc.edu.cn",
        "https://docker.nju.edu.cn"
 
    ]
}

最后记得重启容器哦

关于镜像仓库配置首先你要知道

在Linux中安装Docker后，默认配置的镜像仓库是Docker Hub。Docker Hub是一个公开的注册服务器，其中包含了大量的官方镜像以及用户贡献的镜像。当你在Docker中运行如docker pull ubuntu这样的命令时，如果没有指定其他仓库地址，Docker会默认从Docker Hub下载镜像。

其次如果你没有配置镜像仓库，那么如果需要去指定的镜像仓库拉去或推送镜像，则每次推送或拉取镜像时都需要认证，就像阿里云中的介绍，是比较麻烦，https://cr.console.aliyun.com/repository/cn-hangzhou/pikaqiu-hub/pikaqiu/details

为了避免每次推送或拉取镜像时都需要认证，可以配置镜像仓库凭据

首先介绍两个文件

/root/.docker/config.json

/root/.docker/config.json 是一个位于Linux系统根用户目录.docker隐藏文件夹中的JSON格式配置文件。它主要用于存储Docker客户端的认证信息，比如 Docker Hub 或其他私有 registry 的用户名、密码（经过加密处理）以及访问令牌等认证凭据。此外，该文件还可以包含Docker CLI的默认配置，比如proxies设置。当用户通过Docker命令行与Docker daemon交互，进行镜像拉取、推送等操作时，Docker客户端会自动引用此文件中的认证信息，以实现权限验证和管理。

/etc/docker/daemon.json

_daemon.json_是Docker守护进程的配置文件，它允许系统管理员自定义Docker守护程序的行为。此文件通常位于_/etc/docker/_目录下。通过修改_daemon.json_，可以调整Docker守护进程的多种设置，包括网络配置、日志记录、存储驱动等。

下面是**daemon.json文件的简单配置**

{
  "debug": true,                   // 启用 Docker 守护进程的调试日志
  "registry-mirrors": [           // 设置 Docker 镜像仓库的镜像源，加速拉取镜像
    "https://your.mirror.address"
  ],
  "live-restore": true,            // 当 Docker 守护进程重启时，保持正在运行的容器不被停止
  "insecure-registries": [        // 添加不受信任的私有 Docker 注册表
    "myinsecueregistry:5000"
  ],
  "max-concurrent-downloads": 5,   // 最大并发下载数量
  "iptables": false,               // 禁用 Docker 自动管理 iptables 规则
  "log-driver": "json-file",       // 设置日志驱动，默认为 json-file，也可以是 syslog、journald 等
  "log-opts": {                    // 日志驱动的额外选项
    "max-size": "100m",
    "max-file": "3"
  }
}

下面是/root/.docker/config.json文件的简单（**镜像仓库）配置**

{
        "auths": {
                "registry.cn-hangzhou.aliyuncs.com": {
                        "auth": "加密后的密码"
                }
        }
}

最后修改配置后记得重启容器

1 2	sudo systemctl daemon-reload sudo systemctl restart docker

学识浅薄，疏漏难免，祈望高贤不吝赐教。

Docker的网络模式详解与应用

Tue, 03 Sep 2024 09:34:01 GMT

前言

Docker作为一个革命性的技术平台，极大地简化了应用程序的部署、管理和扩展过程，其中容器网络是其核心组件之一，对于充分挖掘Docker潜力至关重要。虽然不少开发者和IT专业人员可能已经接触或应用过Docker，但深入理解其网络机制仍然是提升容器化技能的关键步骤。本文旨在提供一个全面而深入的指南，帮助您不仅了解Docker网络的基础，还能掌握其高级特性和最佳实践。

Docker内置网络

当我们完成docker engine的安装以后，docker会在每一个engine上面生成一个3种网络，他们是：bridge, none还有host。

bridge

基本概念

当Docker进程启动时，会在主机上创建一个名为docker0的虚拟网桥，此主机上启动的Docker容器会连接到这个虚拟网桥上。虚拟网桥的工作方式和物理交换机类似，这样主机上的所有容器就通过交换机连在了一个二层网络中。

如下图所示，当Docker1需要访问外网时，请求先到达Docker0虚拟网卡，然后在到达物理网卡，请求就发送出去了。

案例

客户端执行”docker run”命令创建并启动容器。

查看容器信息

1	docker inspect nginx

Docker引擎创建一对虚拟接囗veth pair;并把它们分别放到宿主机和新容器的网络命名空间中。
Docker引擎将宿主机上的veth接囗连接到宿主机的docker0网桥上，并且给它分配一个以 “veth” 开头的名字，如 veth8ead84e@if117。
Docker引擎将容器上的veth接囗改名为 “eth0” ，并且该接囗只有在容器内网络命名空间中是可见的。
Docker引擎从宿主机的dockerO网桥上分配一个空闲的ip地址给容器内的eth0，例如172 .17.0.2。并将容器内eth0的路由网关设置为 docker0 的内部IP地址，例如172 .17.0.1。完成以上的这些步骤后，容器就可以使用其内部的虚拟接囗”eth0”来连接到其他的容器和访问外部的网络了。

由于上面启动nginx容器的时候使用的是默认的bridge网络，并且也没有添加端口映射，所以iptables不会做DNAT规则

如果启动容器的时候做了端口映射，则iptables会做DNAT规则，实现端口转发功能，可以使用iptables -t nat -nL查看

工作原理

在 Docker 中启动容器时，如果没有指定网络模式，它默认连接到 Docker 主机上的一个桥接网络。这个桥接网络起初是空的，当容器连接到它时，Docker 会为每个容器分配一个 IP 地址和一个网络接口，并将这个接口连接到虚拟桥接上。

Docker 的桥接网络通常使用 NAT（网络地址转换）来连接到物理网络，使得容器能够通过宿主机的 IP 地址访问外部网络。

使用场景

隔离容器网络环境：当你希望运行的每个容器都有独立的网络堆栈时，Bridge网络非常有用。每个使用Bridge网络的容器都会获得自己的IP地址，并且容器之间的网络通信需要通过端口映射来进行，这提供了基本的网络隔离。
快速部署和测试：在开发和测试环境中，Bridge网络可以让开发者快速搭建一个与外部网络隔离的环境来部署和测试应用，而不会影响到主机或其他网络环境。
服务发现：虽然基础的Bridge网络不直接支持服务发现，但通过结合DNS解析（如使用docker-compose或Kubernetes中的服务发现机制）可以在一定程度上实现容器间的服务发现和通信。
端口映射：当需要从宿主机或其他网络访问容器内的服务时，可以使用Bridge网络并通过端口映射功能将容器的内部端口映射到宿主机的一个端口上，便于外部访问。
多主机通信需求不高场景：对于一些简单的多容器应用，如果不需要跨主机的容器网络通信，或者可以通过其他手段（如使用外部负载均衡器）来实现跨主机通信，使用Bridge网络就足够了。
轻量级解决方案：相比于更复杂的网络解决方案如overlay网络（用于跨多个Docker主机的容器通信）或macvlan网络，Bridge网络更简单、轻量，适合对网络需求不复杂的场景。

host

基本概念

host 模式：使用 –net=host 指定

相当于VMware 中的桥接模式，与宿主机在同一个网络中，但是没有独立IP地址

Docker 使用了Linux 的Namespace 技术来进行资源隔离，如PID Namespace隔离进程，Mount Namespace隔离文件系统，Network Namespace 隔离网络等。一个Network Namespace 提供了一份独立的网络环境，包括网卡，路由，iptable 规则等都与其他Network Namespace 隔离。一个Docker 容器一般会分配一个独立的Network Namespace

但是如果启动容器的时候使用host 模式，那么这个容器将不会获得一个独立的Network Namespace ，而是和宿主机共用一个Network Namespace 。容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口范围.此时容器不再拥有隔离的、独立的网络栈。不拥有所有端口资源

案例

我们拉起一个host网络的centos容器，查看容器信息，如下图所示，并没有发现IP信息

1 2	docker run -itd --net=host --name centos7 eeb6ee3f44bd docker inspect centos7

我们可以进入容器内部去查看下网络信息，通过下图发现，host网络模式下的容器的IP和宿主机IP一致

//进入容器
docker exec -it centos7 bash
//安装网络工具
yum install net-tools -y
//查看IP
ifconfig

工作原理

主机网络模式下，容器将不会获得独立的 IP 地址。容器的网络堆栈将直接映射到宿主机上，容器内的网络服务可以直接绑定到宿主机的 IP 地址和端口上。这种模式通常用于需要进行大量网络操作或需要提供高性能网络服务的场景。

使用场景

性能敏感型应用：当容器化应用需要最大化网络性能时，使用主机网络是一个好选择。因为它消除了网络虚拟化带来的额外开销。
端口冲突：在主机网络模式下，容器可以直接使用宿主机的端口，避免了端口映射可能带来的端口冲突问题。
网络监控和管理：对于需要进行网络监控和管理的工具，主机网络模式能够提供更广泛的网络可视性和控制能力。

none

基本概念

使用none模式，Docker容器拥有自己的Network Namespace，但是，并不为Docker容器进行任何网络配置。也就是说，这个Docker容器没有网卡、IP、路由等信息。需要我们自己为Docker容器添加网卡、配置IP等。

案例

启动一个none网络的centos7的容器，查容器信息

1 2	docker run -itd --name centos7 --net=none eeb6ee3f44bd docker inspect centos7

进入容器查看网络信息

//进入容器
docker exec -it centos7 bash
//安装网络工具
yum install net-tools -y
//查看IP
ifconfig

！！！大佬救命

这里可能处于none网络的原因，导致上面安装网络工具的时候失败
//安装网络工具
yum install net-tools -y
执行日志：
Loaded plugins: fastestmirror, ovl
Loading mirror speeds from cached hostfile
http://mirrors.cloud.aliyuncs.com/centos/7/os/x86_64/repodata/repomd.xml: [Errno 14] curl#6 - “Could not resolve host: mirrors.cloud.aliyuncs.com; Unknown error”
Trying other mirror.
One of the configured repositories failed (CentOS-7),
and yum doesn’t have enough cached data to continue. At this point the only
safe thing yum can do is fail. There are a few ways to work “fix” this:
Contact the upstream for the repository and get them to fix the problem.
Reconfigure the baseurl/etc. for the repository, to point to a working
upstream. This is most often useful if you are using a newer
distribution release than is supported by the repository (and the
packages for the previous distribution release still work).
Run the command with the repository temporarily disabled
yum –disablerepo=base …
Disable the repository permanently, so yum won’t use it by default. Yum
will then just ignore the repository until you permanently enable it
again or use –enablerepo for temporary usage:
yum-config-manager –disable base
or
subscription-manager repos –disable=base
Configure the failing repository to be skipped, if it is unavailable.
Note that yum will try to contact the repo. when it runs most commands,
so will have to try and fail each time (and thus. yum will be be much
slower). If it is a very temporary problem though, this is often a nice
compromise:
yum-config-manager –save –setopt=base.skip_if_unavailable=true
failure: repodata/repomd.xml from base: [Errno 256] No more mirrors to try.
http://mirrors.cloud.aliyuncs.com/centos/7/os/x86_64/repodata/repomd.xml: [Errno 14] curl#6 - “Could not resolve host: mirrors.cloud.aliyuncs.com; Unknown error”

container

基本概念

这个模式指定新创建的容器和已经存在的一个容器共享一个 Network Namespace，而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的 IP，而是和一个指定的容器共享 IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。因此，在这种模式下，容器之间可以通过 localhost 或者 127.0.0.1 进行相互间的访问，从而提高了传输的效率。

案例

首先创建个基础容器

1	docker run -itd --name centos7.A eeb6ee3f44bd

然后基于刚才的容器创建新的容器

1	docker run -itd --net=container:04dcd560b6ce --name centos7.B eeb6ee3f44bd

对比上面创建的两个容器centos7.A和centos7.B发现使用了相同的网络命名空间，这是因为在创建容器B时使用了container模式，使得容器B不再创建自己的网络命名空间，而直接使用容器A的网络命名空间。

自定义网络

上面介绍的3种自带的网络模式有各自的局限性，因此，docker推荐大家自定义网络。通过自定义网络，我们可以实现“服务发现”与“DNS解析”。

docker 允许我们创建3种类型的自定义网络，bridge，overlay，MACVLAN

bridge：Bridge模式是Docker默认的网络模式，当Docker进程启动时，会在主机上创建一个名为docker0的虚拟网桥，用来连接宿主机和容器，此主机上的Docker容器都会连接到这个虚拟网桥上
overlay：当有多个docker主机时，跨主机的container通信
macvlan：每个container都有一个虚拟的MAC地址

bridge

基本概念

虽然Docker提供的默认bridge网络能满足很多基本需求，但在某些场景下，你可能需要创建自定义的bridge网络以实现更灵活的网络配置，比如指定子网、IP范围、网桥名称等。

自定义bridge网络为Docker容器提供了更灵活和可控的网络配置方式，它不仅能够帮助用户更好地组织和隔离容器网络，还支持更复杂的网络架构设计，满足不同应用场景的需求。通过精细的网络配置，可以有效地提升容器化应用的部署效率和管理便利性。

案例

首先创建一个网络（这里创建的时候没有指定子网网段）

1	docker network create -d bridge test_bridge

看下内置网络bridge和我们创建的test_bridge网络有什么区别

1 2	docker inspect test_bridge docker inspect bridge

自定义test_bridge网络

内置网络bridge

基于自定义网络test_bridge创建一个容器

1	docker run -itd --name centos7.test --net=test_bridge eeb6ee3f44b

进入容器查看网络信息，会发现分配的ip在172.18.0.0/16网段中

Docker网络允许您将容器附加到任意数量的网络

将我们之前创建的centos7.A容器加入到test_bridge网络中，先看下centos7.A容器最初的网络信息

1	docker network connect test_bridge centos7.A

断开centos7.A容器和test_bridge网络的连接

1	docker network disconnect test_bridge centos7.A

使用方法

docker network create --driver bridge --subnet=172.18.0.0/16 my-bridge-network

--driver bridge 指定了网络类型为bridge。
--subnet=172.18.0.0/16 指定了网络的子网和CIDR，你可以根据需要选择合适的子网。
my-bridge-network 是自定义网络的名称。

overlay

基本概念

覆盖网络（Overlay Network）是 Docker 的一个高级网络类型，主要用于 Docker Swarm 集群环境中。它允许不同 Docker 主机上的容器相互通信，无论它们的物理位置如何。覆盖网络通过在宿主机之间创建一个虚拟网络层，来连接分布在不同节点上的容器。

工作原理

覆盖网络使用网络驱动（如 VXLAN）在宿主机之间建立一个虚拟网络。这个网络工作在现有的物理网络之上，容器之间的通信会被封装并通过这个虚拟网络传输。当数据包到达目的地后，它会被解封装并传递给目标容器。这种方式使得容器间能够透明地通信，就像它们在同一个网络中一样。

使用场景

多主机容器部署：当你需要在多个 Docker 主机上部署容器，并且这些容器需要相互通信时，覆盖网络是理想的选择。
Docker Swarm 集群：在 Docker Swarm 环境中，覆盖网络允许不同节点上的服务实例之间进行通信，非常适合微服务架构。
跨主机负载均衡：覆盖网络支持跨多个宿主机的负载均衡，使得服务可以更加灵活地扩展和管理。

使用方法

要在 Docker Swarm 环境中创建一个覆盖网络，首先确保你的 Docker 环境已经初始化为 Swarm 模式，然后使用以下命令创建覆盖网络：

1	docker network create -d overlay my_overlay_network

创建了覆盖网络后，你可以在部署服务时指定使用这个网络：

1	docker service create --name my_service --network my_overlay_network my_image

注意事项

网络性能：由于覆盖网络中存在数据封装和解封装的过程，可能会对网络性能造成一定影响。
安全性：Docker 提供了网络加密选项来保护覆盖网络中的数据传输。
网络管理：管理覆盖网络可能需要对 Docker Swarm 集群的管理和网络原理有一定的了解。

macvlan

基本概念

Macvlan 网络是 Docker 提供的另一种网络类型，允许容器直接连接到物理网络。每个使用 Macvlan 网络的容器都会被分配一个独立的 MAC 地址，使其在网络上表现得就像是一个物理设备一样。这种网络类型适用于需要容器直接参与物理网络的场景，例如，当容器需要有自己的 IP 地址、或需要绕过 Docker 网络堆栈的复杂性时。

工作原理

Macvlan 网络通过创建一个或多个虚拟网络接口（Macvlan 接口）来工作，这些接口附加到宿主机的物理网络接口上。每个接口都有自己的 MAC 地址，容器通过这些虚拟接口与外部网络进行通信。这样，容器可以直接出现在物理网络上，而不是通过 Docker 主机的网络堆栈。

使用场景

需要直接网络访问：对于需要绕过 NAT、或需要与外部网络中的其他设备直接通信的容器，Macvlan 网络是一个理想的选择。
遗留系统集成：在一些遗留系统或需要直接网络访问的环境中，Macvlan 网络可以帮助容器更好地集成进这些环境中。
网络性能：由于容器直接连接到物理网络，Macvlan 可以提供更好的网络性能，减少虚拟化带来的开销。

使用方法

创建 Macvlan 网络的基本步骤如下：

创建 Macvlan 网络：

1	docker network create -d macvlan --subnet=192.168.1.0/24 --gateway=192.168.1.1 -o parent=eth0 my_macvlan_net

这个命令会在宿主机的 eth0 网络接口上创建一个新的 Macvlan 网络，设置了子网和网关。

运行容器并连接到 Macvlan 网络：

1	docker run --network my_macvlan_net --name my_container my_image

这个命令启动一个容器，并将其连接到刚刚创建的 Macvlan 网络。

注意事项

网络隔离：使用 Macvlan 网络时，容器的网络隔离级别较低，容器直接暴露在物理网络上
路由和防火墙配置：可能需要在网络设备或宿主机上进行额外的路由和防火墙配置，以确保网络通信的正确性和安全性。
宿主机通信：默认情况下，使用 Macvlan 的容器可能无法与其宿主机进行直接通信。这可能需要额外的网络配置来解决。

总结

Docker 网络是容器化技术中不可或缺的一部分，它不仅提供了容器之间以及容器与外部世界之间通信的能力，还支持了高度的网络隔离和安全性。通过不同的网络类型和配置，Docker 能够满足各种应用场景的需求，从简单的单机部署到复杂的多主机、跨主机的集群环境。

briadge网络作为默认的网络类型，适用于大多数标准部署场景，提供了容器与外部网络的连接以及容器之间的隔离。host网络模式提供了最高的网络性能，适用于性能敏感型应用。overlay网络支持跨主机的容器通信，是在 Docker Swarm 集群中运行分布式应用的理想选择。Macvlan 网络则允许容器直接连接到物理网络，适用于需要直接网络访问或遗留系统集成的场景。

每种网络类型都有其适用场景和注意事项。选择合适的网络类型和配置，可以帮助开发者和运维人员构建高效、安全且易于管理的容器化应用。同时，Docker 的网络配置和管理工具也提供了灵活性和便利性，使得网络管理变得更加简单。

Docker 网络提供了强大而灵活的网络功能，支持各种应用部署和运行模式。通过合理选择和配置网络类型，可以最大化地发挥 Docker 容器的潜力，构建出高性能、安全且易于管理的容器化应用。

WordPress纯代码实现圆角彩色背景标签云

Tue, 20 Aug 2024 14:17:35 GMT

一、前言

**标签云 **对我们的文章画龙点睛，如果让我们的标签云随机产生彩色效果，更是增加了不是个性化，我们现在抛弃插件，自己动手从网上学习DIY自己的彩色标签云。

二、代码部署

代码需放入主题目录下的tag-color-cloud.php文件中


/**
 * 彩色圆角标签云
 */
if ( ! defined( 'ABSPATH' ) ) { exit; }

function colorCloud( $text ) {
    return preg_replace_callback(
        '||i',
        function ( $m ) {
            $colors = array( 'F99', 'C9C', 'F96', '6CC', '6C9', '37A7FF', 'B0D686', 'E6CC6E' );
            $color  = $colors[ array_rand( $colors ) ];

            // 去掉原有的 style 属性（若有）
            $attrs = preg_replace( '/style=(["\'])(.*?)\1/i', '', $m[1] );

            // 追加新样式
            $style  = "display:inline-block;color:#fff;padding:1px 5px;margin:0 5px 5px 0;";
            $style .= "background-color:#{$color};border-radius:3px;";
            $style .= "transition:background-color .4s linear;";

            return '' . $attrs . ' style="' . $style . '">';
        },
        $text
    );
}
add_filter( 'wp_tag_cloud', 'colorCloud', 10 );

最后在functions.php中调用即可

1 2	/* 彩色圆角标签云 */ require_once get_template_directory() . '/self-innovate/tag-color-cloud.php';

快速迁移网站

Mon, 22 Jul 2024 12:34:22 GMT

一、前言

从建站开始到现在也有一年了，也看着服务器马上就要到期了。现在有俩个选择可以解决这个问题，其一是在现有的服务器上选择续费，但是成本很高，由于笔者的网站在建站的这一年之内也没有什么收入，所以很难拿出这么一大笔的费用，那么只能选择其二了，那就是购买一台新的服务器，毕竟在有活动的时候够买，相对来说还是很便宜的，但是如果购买新的服务器的话，也会面临一定的问题比如如何将网站从旧的服务器迁移到新的服务器。

先总结一下迁移的思路吧：

首先要给新的服务器安装上和旧服务器一样的宝塔环境，包括php版本、mysql版本，这样能避免网站数据出错。
网站数据一定要提前备份，防止出现其他问题可以方便恢复。
然后在发送数据服务器上安装一键迁移工具，填写接收数据服务器信息，包括秘钥，就可以开始自动迁移了。

二、安装迁移工具

直接在宝塔面板的软件商店搜索一键迁移，即可找到宝塔一键迁移API版本，点击安装即可。

三、配置API

接收数据服务器上，点击面板设置，开启API，获得接口秘钥，并将发送数据端IP加入接收数据服务器API的IP白名单，最后点击保存即可。

四、开启迁移

发送数据服务器上，找到我们刚刚下载的宝塔一键迁移API版本，填写面板地址和API秘钥。
注意：面板地址和API秘钥都是接收数据服务器、接收数据服务器、接收数据服务器上的，千万别填错了。
面板地址包含协议 + 主机IP地址 + 面板端口
例如：http://192.168.0.1:8888

五、解析测试

迁移完成后，网站文件和数据库就都已经到新的网站了，这个时候域名再重新解析到新的网站就可以正常访问了。

DOCKER容器拉起后如何添加新的端口映射

Thu, 18 Jul 2024 07:08:57 GMT

前段时间在用docker部署服务的时候发现，容器已经启动，但是需要新的端口映射（即容器在启动的时候只进行了部分的端口映射），经过查询资料后发现现在网上有2种方法，一中是修改json文件。另一种是将已经运行的容器打包成一个新的镜像，然后基于打包后的镜像来在启动容器的时候开启全部的端口映射。但是经过我的测试发现第一种修改json文件的方式好像会重置容器。

方法一

停止docker服务

1	systemctl stop docker

修改json文件，一般要修改的文件在/var/lib/docker/containers/下，找到要修改的容器然后进入目录即可看到hostconfig.json和config.v2.json

**config.v2.json：**Docker容器的配置文件之一，包含了容器的配置信息，如环境变量、端口映射、卷挂载点等。版本2表示这是Docker引入新配置格式后的文件。
**hostconfig.json：**另一个重要的Docker容器配置文件，包含了容器的主机配置信息，比如网络模式、资源限制(如CPU份额和内存限制)、重启策略等。

按照格式添加端口即可

启动docker服务

1	systemctl stat docker

经过这种方式修改后确实会添加新的端口映射，但是容器也好像会被重置。除了这个问题因为这种方式还涉及到了docker的启停，若是容器过多的话会影响到别的业（不推荐）

方法二

将容器打包成镜像，然后基于打包后的镜像来在启动容器的时候开启全部的端口映射即可

若是还有别的方法或者文章中有错误的话请指出！！！

Docker attach V/S Docker exec

Thu, 18 Jul 2024 07:08:27 GMT

docker exec和docker attach都是进入容器的命令但是它么两个有一些区别你们知道吗？

docker attach 语法

attach是Docker自带的命令，命令的语法为：

1	docker attach 容器ID

docker exec 语法

从Docker的1.3版本起，Docker提供了更加方便的工具exec命令，可以在运行容器内直接执行任意命令。命令语法为：

1	docker exec -it 容器ID bash

两者区别

当多个窗口同是attach到同一个容器的时候，所有窗口都会同步显示；当某个窗口因命令阻塞时，其他窗口也无法执行操作。
可以使用 docker exec -it 容器id /bin/bash 进入容器并开启一个新的bash终端。使用exit或者Ctrl+d退出容器终端时，不会导致容器的停止。
使用 docker attach 容器id 进入正在执行容器，不会启动新的终端，使用exit或者Ctrl+d退出容器时，会导致容器的停止，但是使用Ctrl+p+q退出后容器不会停止。

Docker生命周期和原理

Tue, 18 Jun 2024 07:08:41 GMT

1.Docker生命周期

废话少说直接看图

2.Docker原理

作为大神或者准架构师/架构师，一定要了解一下docker的底层原理__。

所有对容器的修改动作，都只会发生在容器层里，只有容器层是可写的，其余镜像层都是只读的

3. 总结

一句话Docker是分层的

WordPress中Gravatar头像无法访问

Mon, 27 May 2024 14:44:01 GMT

一、前言

一般情况下，WordPress默认都是使用Gravatar头像，如果用户没有注册过Gravatar头像，那就使用网站设置的默认头像，这样用户体验不是很好；再则，如果直接调用远程Gravatar头像，还会影响网站的加载速度(WordPress缓存Gravatar头像到本地，提高加载速度)。所以，作为一个开放注册的WordPress网站而言，在用户资料页面添加自定义用户头像功能是极为重要的。

Gravatar有时候无法访问导致头像显示不出来，只能使用默认的头像，要解决这个问题我这有三种方法：

使用Simple Local Avatars插件
代码配置、
使用国内的Gravatar为 WordPress 集成

总体来说插件是最简单稳定的，下面会分别介绍这三种方法，大家可以自行选择

二、插件

站长可以在 WordPress后台直接搜索插件_**Simple Local Avatars**_进行在线安装，启用之后可以在仪表盘>> 用户 >> 我的个人资料进行头像设置，同理管理员也可以修改其他用户头像。

三、代码配置

Simple Local Avatars 是英文的，只有一个主文件 simple-local-avatars.php，你也可以将这个功能直接集成到你的主题中，只需将该插件的 simple-local-avatars.php 放到正在使用的主题的根目录，然后在 functions.php文件中使用下面的代码引入该文件即可：

1	require_once(TEMPLATEPATH . '/simple-local-avatars.php');

通过以上的两种方式，你的网站已经具备了自定义用户头像功能。那么，如何调用自定义头像？很简单，可以调用get_simple_local_avatar 或 get_avatar 函数即可，例如：

1	echo get_avatar(get_the_author_meta('ID')); ?>

如果你已设置了Gravatar头像，也上传了自定义头像，优先显示自定义头像

simple-local-avatars.php 完整代码：


 
/**
 
Plugin Name: Simple Local Avatars
 
Plugin URI: http://get10up.com/plugins/simple-local-avatars-wordpress/
 
Description: Adds an avatar upload field to user profiles if the current user has media permissions. Generates requested sizes on demand just like Gravatar! Simple and lightweight.
 
Version: 1.3.1
 
Author: Jake Goldman (10up LLC), Oomph Inc
 
Author URI: http://get10up.com
 
Plugin: Copyright 2011 Jake Goldman (email : jake@get10up.com)
 
This program is free software; you can redistribute it and/or modify
 
it under the terms of the GNU General Public License as published by
 
the Free Software Foundation; either version 2 of the License, or
 
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
 
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
 
along with this program; if not, write to the Free Software
 
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
NOTE: Previous versions may have accidentally and incorrectly attributed the
 
copyright to employers of Mr. Goldman. While credit is given to all contributors
 
to the current version, including Mr. Goldman's employers, the copyright belongs
- and has always belonged - to Mr. Goldman, personally.
*/
/**
* add field to user profiles
*/
class Simple_Local_Avatars {
private $user_id_being_edited;
public function __construct() {
add_filter( 'get_avatar', array( $this, 'get_avatar' ), 10, 5 );
add_action( 'admin_init', array( $this, 'admin_init' ) );
add_action( 'show_user_profile', array( $this, 'edit_user_profile' ) );
add_action( 'edit_user_profile', array( $this, 'edit_user_profile' ) );
add_action( 'personal_options_update', array( $this, 'edit_user_profile_update' ) );
add_action( 'edit_user_profile_update', array( $this, 'edit_user_profile_update' ) );
add_filter( 'avatar_defaults', array( $this, 'avatar_defaults' ) );
}
public function get_avatar( $avatar = '', $id_or_email, $size = 96, $default = '', $alt = false ) {
if ( is_numeric($id_or_email) )
$user_id = (int) $id_or_email;
elseif ( is_string( $id_or_email ) && ( $user = get_user_by( 'email', $id_or_email ) ) )
$user_id = $user->ID;
elseif ( is_object( $id_or_email ) && ! empty( $id_or_email->user_id ) )
$user_id = (int) $id_or_email->user_id;
if ( empty( $user_id ) )
return $avatar;
$local_avatars = get_user_meta( $user_id, 'simple_local_avatar', true );
if ( empty( $local_avatars ) || empty( $local_avatars['full'] ) )
return $avatar;
$size = (int) $size;
if ( empty( $alt ) )
$alt = get_the_author_meta( 'display_name', $user_id );
// generate a new size
if ( empty( $local_avatars[$size] ) ) {
$upload_path = wp_upload_dir();
$avatar_full_path = str_replace( $upload_path['baseurl'], $upload_path['basedir'], $local_avatars['full'] );
$image_sized = image_resize( $avatar_full_path, $size, $size, true );
// deal with original being >= to original image (or lack of sizing ability)
$local_avatars[$size] = is_wp_error($image_sized) ? $local_avatars[$size] = $local_avatars['full'] : str_replace( $upload_path['basedir'], $upload_path['baseurl'], $image_sized );
// save updated avatar sizes
update_user_meta( $user_id, 'simple_local_avatar', $local_avatars );
} elseif ( substr( $local_avatars[$size], 0, 4 ) != 'http' ) {
$local_avatars[$size] = home_url( $local_avatars[$size] );
}
$author_class = is_author( $user_id ) ? ' current-author' : '' ;
$avatar = "" . esc_attr( $alt ) . "' src='" . $local_avatars[$size] . "' class='avatar avatar-{$size}{$author_class} photo' height='{$size}' width='{$size}' />";
return apply_filters( 'simple_local_avatar', $avatar );
}
public function admin_init() {
load_plugin_textdomain( 'simple-local-avatars', false, dirname( plugin_basename( __FILE__ ) ) . '/localization/' );
register_setting( 'discussion', 'simple_local_avatars_caps', array( $this, 'sanitize_options' ) );
add_settings_field( 'simple-local-avatars-caps', __('Local Avatar Permissions','simple-local-avatars'), array( $this, 'avatar_settings_field' ), 'discussion', 'avatars' );
}
public function sanitize_options( $input ) {
$new_input['simple_local_avatars_caps'] = empty( $input['simple_local_avatars_caps'] ) ? 0 : 1;
return $new_input;
}
public function avatar_settings_field( $args ) {
$options = get_option('simple_local_avatars_caps');
echo '
 
for="simple_local_avatars_caps">
 
type="checkbox" name="simple_local_avatars_caps" id="simple_local_avatars_caps" value="1" ' . @checked( $options['simple_local_avatars_caps'], 1, false ) . ' />
 
' . __('Only allow users with file upload capabilities to upload local avatars (Authors and above)','simple-local-avatars') . '
 

 
';
}
public function edit_user_profile( $profileuser ) {
?>
Avatar','simple-local-avatars' ); ?>






Upload Avatar','simple-local-avatars'); ?> 
ID ); ?>


$options = get_option('simple_local_avatars_caps');
if ( empty($options['simple_local_avatars_caps']) || current_user_can('upload_files') ) {
do_action( 'simple_local_avatar_notices' );
wp_nonce_field( 'simple_local_avatar_nonce', '_simple_local_avatar_nonce', false );
?>



if ( empty( $profileuser->simple_local_avatar ) )
echo '"description">' . __('No local avatar is set. Use the upload field to add a local avatar.','simple-local-avatars') . '';
else
echo '
 
type="checkbox" name="simple-local-avatar-erase" value="1" /> ' . __('Delete local avatar','simple-local-avatars') . '

 
"description">' . __('Replace the local avatar by uploading a new avatar, or erase the local avatar (falling back to a gravatar) by checking the delete option.','simple-local-avatars') . '
 
';
} else {
if ( empty( $profileuser->simple_local_avatar ) )
echo '"description">' . __('No local avatar is set. Set up your avatar at Gravatar.com.','simple-local-avatars') . '';
else
echo '"description">' . __('You do not have media management permissions. To change your local avatar, contact the blog administrator.','simple-local-avatars') . '';
}
?>



}
public function edit_user_profile_update( $user_id ) {
if ( ! isset( $_POST['_simple_local_avatar_nonce'] ) || ! wp_verify_nonce( $_POST['_simple_local_avatar_nonce'], 'simple_local_avatar_nonce' ) ) //security
return;
if ( ! empty( $_FILES['simple-local-avatar']['name'] ) ) {
$mimes = array(
'jpg|jpeg|jpe' => 'image/jpeg',
'gif' => 'image/gif',
'avif' => 'image/avif',
'bmp' => 'image/bmp',
'tif|tiff' => 'image/tiff'
);
// front end (theme my profile etc) support
if ( ! function_exists( 'wp_handle_upload' ) )
require_once( ABSPATH . 'wp-admin/includes/file.php' );
$this->avatar_delete( $user_id ); // delete old images if successful
// need to be more secure since low privelege users can upload
if ( strstr( $_FILES['simple-local-avatar']['name'], '.php' ) )
wp_die('For security reasons, the extension ".php" cannot be in your file name.');
$this->user_id_being_edited = $user_id; // make user_id known to unique_filename_callback function
$avatar = wp_handle_upload( $_FILES['simple-local-avatar'], array( 'mimes' => $mimes, 'test_form' => false, 'unique_filename_callback' => array( $this, 'unique_filename_callback' ) ) );
if ( empty($avatar['file']) ) { // handle failures
switch ( $avatar['error'] ) {
case 'File type does not meet security guidelines. Try another.' :
add_action( 'user_profile_update_errors', create_function('$a','$a->add("avatar_error",__("Please upload a valid image file for the avatar.","simple-local-avatars"));') );
break;
default :
add_action( 'user_profile_update_errors', create_function('$a','$a->add("avatar_error","".__("There was an error uploading the avatar:","simple-local-avatars")." ' . esc_attr( $avatar['error'] ) . '");') );
}
return;
}
update_user_meta( $user_id, 'simple_local_avatar', array( 'full' => $avatar['url'] ) ); // save user information (overwriting old)
} elseif ( ! empty( $_POST['simple-local-avatar-erase'] ) ) {
$this->avatar_delete( $user_id );
}
}
/**
* remove the custom get_avatar hook for the default avatar list output on options-discussion.php
*/
public function avatar_defaults( $avatar_defaults ) {
remove_action( 'get_avatar', array( $this, 'get_avatar' ) );
return $avatar_defaults;
}
/**
* delete avatars based on user_id
*/
public function avatar_delete( $user_id ) {
$old_avatars = get_user_meta( $user_id, 'simple_local_avatar', true );
$upload_path = wp_upload_dir();
if ( is_array($old_avatars) ) {
foreach ($old_avatars as $old_avatar ) {
$old_avatar_path = str_replace( $upload_path['baseurl'], $upload_path['basedir'], $old_avatar );
@unlink( $old_avatar_path );
}
}
delete_user_meta( $user_id, 'simple_local_avatar' );
}
public function unique_filename_callback( $dir, $name, $ext ) {
$user = get_user_by( 'id', (int) $this->user_id_being_edited );
$name = $base_name = sanitize_file_name( $user->display_name . '_avatar' );
$number = 1;
while ( file_exists( $dir . "/$name$ext" ) ) {
$name = $base_name . '_' . $number;
$number++;
}
return $name . $ext;
}
}
$simple_local_avatars = new Simple_Local_Avatars;
/**
* more efficient to call simple local avatar directly in theme and avoid gravatar setup
*
* @param int|string|object $id_or_email A user ID, email address, or comment object
* @param int $size Size of the avatar image
* @param string $default URL to a default image to use if no avatar is available
* @param string $alt Alternate text to use in image tag. Defaults to blank
* @return string  tag for the user's avatar
 
*/
 
function get_simple_local_avatar( $id_or_email, $size = '96', $default = '', $alt = false ) {
 
global $simple_local_avatars;
 
$avatar = $simple_local_avatars->get_avatar( '', $id_or_email, $size, $default, $alt );
 
if ( empty ( $avatar ) )
 
$avatar = get_avatar( $id_or_email, $size, $default, $alt );
 
return $avatar;
 
}
 
/**
 
* on uninstallation, remove the custom field from the users and delete the local avatars
 
*/
 
register_uninstall_hook( __FILE__, 'simple_local_avatars_uninstall' );
 
function simple_local_avatars_uninstall() {
 
$simple_local_avatars = new Simple_Local_Avatars;
 
$users = get_users_of_blog();
 
foreach ( $users as $user )
 
$simple_local_avatars->avatar_delete( $user->user_id );
 
delete_option('simple_local_avatars_caps');
 
}

四、_Gravatar_集成

1 、注意，以下主题因为使用自有的头像方案，完全屏蔽了 Gravatar，所以也不支持 Gravatar： 7b2 日主题子比主题 2 、对于此类主题、插件仍需适配 Gravatar？请到支持论坛中开贴↗获取帮助。 3 、如果您是普通用户不想要改代码，快速使用请安装文派头像（WPAvatar）↗插件。

1	您可以很方便的为 WordPress 集成 Gravatar 头像服务，只需要将以下代码加入您的插件或主题的 functions.php 里即可：

Gravatar 官网文档：https://cravatar.com/developer/for-wordpress

if ( ! function_exists( 'get_cravatar_url' ) ) {
    /**
     * 替换 Gravatar 头像为 Gravatar 头像
     *
     * Gravatar 是 Gravatar 在中国的完美替代方案，您可以在 https://cravatar.com 更新您的头像
     */
    function get_cravatar_url( $url ) {
        $sources = array(
            'www.gravatar.com',
            '0.gravatar.com',
            '1.gravatar.com',
            '2.gravatar.com',
            'secure.gravatar.com',
            'cn.gravatar.com',
            'gravatar.com',
        );
        return str_replace( $sources, 'cravatar.cn', $url );
    }
    add_filter( 'um_user_avatar_url_filter', 'get_cravatar_url', 1 );
    add_filter( 'bp_gravatar_url', 'get_cravatar_url', 1 );
    add_filter( 'get_avatar_url', 'get_cravatar_url', 1 );
}
if ( ! function_exists( 'set_defaults_for_cravatar' ) ) {
    /**
     * 替换 WordPress 讨论设置中的默认头像
     */
    function set_defaults_for_cravatar( $avatar_defaults ) {
        $avatar_defaults['gravatar_default'] = 'Gravatar 标志';
        return $avatar_defaults;
    }
    add_filter( 'avatar_defaults', 'set_defaults_for_cravatar', 1 );
}
if ( ! function_exists( 'set_user_profile_picture_for_cravatar' ) ) {
    /**
     * 替换个人资料卡中的头像上传地址
     */
    function set_user_profile_picture_for_cravatar() {
        return ' 您可以在 Gravatar 修改您的资料图片';
    }
    add_filter( 'user_profile_picture_description', 'set_user_profile_picture_for_cravatar', 1 );
}

您可以在 Gravatar 修改您的资料图片：https://cn.cravatar.com/avatars

至此三种配置方法已经完成，希望能帮助到您

人机验证解决VAPTCHA

Thu, 14 Dec 2023 12:51:49 GMT

一、引言

CAPTCHA 是“Completely Automated Public Turing Test* to Tell Humans Apart（全自动区分计算机和人类的图灵测试）”的首字母缩写。它是指各种认证方法，这些方法利用一个对于人类来说很简单但对机器来说很难的挑战来测试用户，以验证用户是否为人类。 CAPTCHA 可防止诈骗者和垃圾邮件发送者使用机器人填写用于恶意目的的 Web 表单。

传统 CAPTCHA 要求用户阅读并正确重新输入无法通过光学字符识别 (OCR) 技术解释的失真文本。最新的 CAPTCHA 技术使用 AI 驱动的行为和风险分析，根据活动模式（而不是单个离散任务）对人类用户进行认证。

许多网站都要求用户在登录到帐户档案、提交注册表、发表评论或执行黑客可能使用机器人执行的某些其他操作之前回答 CAPTCHA 问题。回答这种问题，即表明用户是人类，并被允许在网站上继续执行活动。

注意事项：

如果你使用的主题后台有CAPTCHA的API调用接口，您直接调用即可
如果你使用的主题后台没有CAPTCHA的API调用接口，则您需要自己部署代码然后调用CAPTCHA的API接口实现人机验证

二、主题有自带

2.1、注册

CAPTCHA官网：https://www.vaptcha.com/

2.2、创建验证单元

完成注册后，您将能够在管理界面中生成CAPTCHA的验证ID（VID）和密钥（KEY）。随后，只需在后台的主题设置中进行相应的配置即可启用CAPTCHA功能。

2.3、后台设置

三、主题没有自带

3.1、代码配置

配置流程：

创建验证单元，获取VID和Key 。点击创建。
将https://v-cn.vaptcha.com/v3.js引入到你的页面。
将 VAPTCHA 初始化到你需要的位置，具体 web 端部署请查看：Web 客户端部署。
用户验证通过得到token，与表单数据一同提交到服务端。
服务端得到token后，向 VAPTCHA 服务器验证token的有效性，验证通过说明此次请求有效，服务端验证流程请查看：服务端二次验证。

本文不深入探讨具体的部署步骤，若需了解详细的部署流程，您请参阅 CAPTCHA 官方提供的配置指南。

3.2、插件

VAPTCHA下载：https://pan.baidu.com/s/1sqwhLY4g8t0-0iQoPOHKJQ?pwd=kupa
提取码：kupa

上传安装插件之后即可在后台配置

网站提交搜索引擎

Mon, 08 May 2023 08:35:26 GMT

一、前言

将网站提交给搜索引擎是为了让搜索引擎更早地了解、索引和显示您的网站内容。以下是一些提交网站给搜索引擎的理由：

提高可见性：通过将您的网站提交给搜索引擎，可以提高您的网站在搜索结果中出现的机会。当用户搜索与您的网站相关的关键词时，搜索引擎将更容易找到并显示您的网站。
更快索引网页：搜索引擎通过网络爬虫（也称为蜘蛛）来发现新的网页内容。尽管搜索引擎蜘蛛会定期自动抓取和索引网页，但对于新建立的网站或刚发布的新内容，手动提交可以加快搜索引擎对您网站的索引速度。
更新通知：如果您的网站经常发布新的内容或更新现有内容，手动提交网站给搜索引擎可以让它们意识到您的网站有新的变化，以便更及时地更新索引。
修复索引问题：有时候，搜索引擎可能无法正确索引您的网站或内容，导致网站排名下降或无法出现在搜索结果中。在这种情况下，通过重新提交网站可以帮助搜索引擎重新审视和索引您的网站，以解决问题。

需要注意的是，尽管提交网站给搜索引擎可以加快索引速度和提高可见性，但并不保证搜索引擎会立即或完全索引您的网站。搜索引擎的索引算法是复杂的，排名和显示结果是基于多个因素综合考虑的。因此，除了提交网站给搜索引擎，还应该关注网站内容的质量、结构优化、外部链接等方面，以提高搜索引擎优化（SEO）效果。

二、sitemap

什么是网站地图？

sitemap是一种视觉指南，它以图形化的形式展示网站的结构和内容布局。它帮助用户轻松导航，提升用户体验，并辅助搜索引擎优化。网站地图可以是规划、设计和维护网站时的关键工具，确保信息架构的清晰和易于访问。

2.1、插件生成站点地图

使用Yoast SEO插件可以自动生成sitemap

2.2、工具生成网站地图

工具链接：https://www.xml-sitemaps.com/

将生成的网站 sitemap.xml 文件上传至网站根目录后，搜索引擎就能更高效地抓取和索引页面内容，有助于提升网站在搜索结果中的可见性。确保文件路径正确，一般应为类似https://www.yourdomain.com/sitemap.xml的访问方式。

三、Bing

Bing搜索引擎提交入口：https://www.bing.com/webmasters

Bing网站管理后台提交站点sitemap

Bing提交相关文章：https://www.szlogic.net/learn/seo/site-submit/

四、百度

百度搜索引擎提交入口：https://ziyuan.baidu.com/property/index

百度的平台公告已经发布了“关于回收网站提交配额的通知”该政策是因为需要打击灰产、低质量和未实名认证的网站，官方的完整说明：“由于近期黑产、作弊行为肆虐，大量抢占平台资源，严重影响用户体验，搜索资源平台针对非实名账户内站点、低质站点关停sitemap提交能力并调整API每日推送额度。请各站点做好日常维护和质量管理，资源平台将在节后陆续为合规站点恢复权益、调配额度。

4.1、sitemap提交

4.2、手动提交

百度提交相关文章：https://www.szlogic.net/learn/seo/site-submit/

五、Google

Google搜索引擎提交入口：https://search.google.com/search-console/about

使用Yoast SEO插件生成并提交网站的sitemap后，有时候可能会遇到Google搜索控制台提示无法检索的情况，其实这时候不必过于担心，通常过一会儿系统会自动显示成功，或者在你提交第二个网站地图后，问题也会自动解决。

当然你可以直接使用上面通过在线工具生成的sitemap.xml地图，这样能够方便快捷地为网站整理出结构清晰的索引，有助于搜索引擎更好地抓取和识别网页内容。