MichaelFu

Docker 磁盘占用空间清理

发表于 2023-11-22 分类于 Docker 本文字数： 369 阅读时长 ≈ 1 分钟

记录几种用于清理 Docker 磁盘空间占用的几种方式。

删除不想要的容器、网络、镜像以及构建缓存等，首先使用如下的命令查看 Docker 空间占用：

docker system df

root@ctrlnode:/home/ubuntu# docker system df
TYPE                TOTAL               ACTIVE              SIZE                RECLAIMABLE
Images              15                  14                  2.332GB             13.26kB (0%)
Containers          51                  22                  219B                104B (47%)
Local Volumes       1                   0                   0B                  0B
Build Cache         0                   0                   0B                  0B

如果使用 -v 参数可以查看更具体的每个镜像，容器的占用。使用 docker system prune 命令删除停止状态的容器，未关联容器的网络以及 dangling 镜像，如果使用 -a 参数，还将清除未使用的镜像，-f 表示强制操作:

docker system prune -a -f

如果仅仅是删除未使用的和dangling 镜像使用：

docker image prune -a

类似的，下面的两条命令用于清除停止的容器以及未使用的卷：

docker container prune
docker volume prune

仅删除 dangling 镜像：

docker rmi $(docker images -f “dangling=true” -q)

如果是删除退出的容器：

docker rm -v $(docker ps -aq -f status=exited)
清理日志，编辑文件：/etc/docker/daemon.json：

vi /etc/docker/daemon.json

添加下面这些配置：
1
{ "log-driver":"json-file", "log-opts": {"max-size":"3m", "max-file":"1"} }
重启:

systemctl daemon-reload systemctl restart docker
k8s 环境的清理，首先驱逐节点：

kubectl drain this_node --ignore-daemonsets --delete-local-data

停止 kubelet 服务：

kubelet stop

重启 Docker：

service docker restart

清理 Docker：

docker system prune --all --volumes --force
相当于重装 Docker：

systemctl stop docker
rm -rf /var/lib/docker
systemctl start docker

【multipass】跨平台虚拟机

发表于 2022-11-13 本文字数： 841 阅读时长 ≈ 3 分钟

multipass 是一个很好用的虚拟机软件，基于它能够快速创建出需要的虚拟机环境。

阅读全文 »

Nginx

发表于 2022-10-26 分类于 Nginx 本文字数： 2.9k 阅读时长 ≈ 11 分钟

环境准备

以下使用 docker 准备学习环境。

先拉取centos的最新镜像：docker image pull centos
创建一个数据卷用于存放容器中产生的文件：docker volume create centos
启动我们的容器：docker run -d -it -v centos:/workdir --name centos centos /bin/bash
进入我们的容器：docker exec -it centos /bin/bash

Nginx 的主要应用场景

静态资源服务，即通过本地文件系统提供服务；
反向代理服务，提供缓存，负载均衡功能；
API服务，通过Openresty直接访问数据库；

阅读全文 »

设计模式

发表于 2022-10-07 分类于设计原则本文字数： 47k 阅读时长 ≈ 2:51

设计模式是软件设计中常见问题的典型解决方案。它们就像能根据需求进行调整的预制蓝图，可用于解决代码中反复出现的设计问题。

设计模式与方法或库的使用方式不同，很难直接在自己的程序中套用某个设计模式。模式并不是一段特定的代码，而是解决特定问题的一般性概念。可以根据模式来实现符合自己程序实际所需的解决方案。

人们常常会混淆模式和算法，因为两者在概念上都是已知特定问题的典型解决方案。但算法总是明确定义达成特定目标所需的一系列步骤，而模式则是对解决方案的更高层次描述，同一模式在两个不同程序中的实现代码可能会不一样。

算法更像是菜谱：提供达成目标的明确步骤。而模式更像是蓝图：可以看到最终的结果和模式的功能，但需要自己确定实现步骤。

设计模式从分类上来讲，可以分为创建型、结构型和行为型。

阅读全文 »

SOLID 设计原则

发表于 2022-07-19 分类于设计原则本文字数： 9.6k 阅读时长 ≈ 35 分钟

SOLID 设计原则并非单纯的一个原则，它实际上包含5个设计原则：单一职责原则、开闭原则、里氏替换替换原则，接口隔离原则和依赖反转原则。

单一职责原则（`SRP`）

SRP(Single Responsibility Principle) 这个原则的意思是一个类或者一个模块只负责完成一个功能。所以，这里有两种理解方式，一种理解是把模块看做比类更加抽象的概念，类也可以看做是模块。另一种理解是把类看做是比类更加粗粒度的代码块，模块中包含多个类。

单一职责原则定义非常简单，不难理解。一个类只负责完成一个职责或者功能，也就是说，不要设计大而全的类，要设计粒度小、功能单一的类。换个角度来讲就是，一个雷包含了两个或者两个以上业务不相干的功能，那我们就说它职责不够单一，应该将它拆分成多个功能更加单一、粒度更细的类。举例来讲，如果一个类包含了用户和订单的一些操作，而用户和订单又是独立的业务领域模型，我们将它们放到一起就违反了单一职责原则，我们就需要进行拆分。

不同的应用场景、不同阶段的需求背景、不同的业务层面，对于同一个类的职责是否单一，可能会有不用的判定结果。实际上，一些侧面的判断指标更具有指导意义和可执行性，比如，代码行数过度，函数或者属性过多都可能是违反单一职责原则的表象。

例如，下面的 UserInfo 类，这个类里面除了用户的基本信息，还有地址信息。或许一个观点是都属于用户的基本信息应该放在一起，另一个观点是可以拆分出 UserAddress 类，UserInfo 只保留除 Address 之外的其他信息，拆分之后两个类的职责更加单一。是否应该拆分，取决于具体情况，如果实际中地址信息和基本信息总是同时出现，那放在一起没有问题。但是如果地址信息单独在其他模块中使用，就应该单独抽象成 UserAddress：

public class UserInfo {
  private long userId;
  private String username;
  private String email;
  private String telephone;
  private long createTime;
  private long lastLoginTime;
  private String avatarUrl;
  private String provinveOfAddress;
  private String cityOfAddress;
  private String regionOfAddress;
  private String detailedAddress;
}

单一职责原则指导设计粒度较小的类，职责清晰的类，类的依赖以及被依赖的其他类也很会变少，从而降低代码的耦合性，实现高内聚、低耦合。但是如果拆分的过细，可能会适得其反，影响代码的可维护性。

阅读全文 »

面向对象

发表于 2022-06-20 分类于设计原则本文字数： 9.2k 阅读时长 ≈ 34 分钟

几年前在面试的时候，还经常被面试官问 OOP 的四个特征是什么以及他们背后代表的意思，几年过去了，除了不支持面向对象的语言之外，面向对象编程思想已经深入到了每个开发者的灵魂，只是做的好与不好罢了。

面向对象编程中有两个非常基础的概念，类和对象，面向对象编程是一种编程范式或者说编程风格，它以类或者对象作为组织代码的基本单元，并将封装，继承，抽象，多态作为代码设计和实现的基石，不像面向过程编程语言，以函数为程序中的基本单元。

面向对象编程只是一种编程思想，可以用不同的语言进行实现，即使我们用面向对象语言，也完全可以写出面向过程风格的代码。至于什么是面向对象编程语言，并没有严格的定义，只要它能实现 OOP 的四大特性，那它就是面向对象编程语言，例如：Rust，C++，GO，Java，Python 以及 PHP 等，

面向对象编程的前提是面向对象分析（OOA）和面向对象设计（OOD），这样才能进行面向对象编程（OOP），具备完整的面向对象编程的思维。面向对象分析和设计两个阶段的产物应该是类的设计，包括应用程序应该被分为哪些类，每个类该有哪些属性和方法，类与类之间如何交互等等，它们比较贴近代码，非常具体，容易落地实现。

在 OOA 和 OOD 的过程中，我们会经常用到 UML（Unified Model Language） 工具辅助我们进行工作。UML 是一种比较复杂的工具，除了包括我们常见的类图，还有用例图，顺序图，活动图，状态图，组件图等，即使是类图，类之间的关系就有泛化，实现，关联，聚合，组合以及依赖等，熟练掌握难度比较大，即便你掌握了，你同事不一定掌握，沟通成本依然很高，大多时候，我们会用草图实现我们的设计过程。

阅读全文 »

【Leetcode-Rust】长度最小的子数组(0209)

发表于 2022-06-19 分类于 Leetcode 本文字数： 313 阅读时长 ≈ 1 分钟

题目

给定一个含有 n 个正整数的数组和一个正整数 target。

找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

思路

这一题的解题思路是用滑动窗口。在滑动窗口 [i,j] 之间不断往后移动，如果总和小于 s，就扩大右边界 right，不断加入右边的值，直到 sum >= s，然后判断满足的子数组的长度，再缩小 left 左边界，直到 sum < s，这时候右边界又可以往右移动，寻找下一个满足的子数组。

fn min(a: i32, b: i32) -> i32 {
    if a < b {
        return a;
    }
    b
}

impl Solution {
    pub fn min_sub_array_len(target: i32, nums: Vec<i32>) -> i32 {
        let mut left = 0usize;
        let mut sum = 0;
        let mut res = nums.len() as i32 + 1;
        for right in 0..nums.len() {
            let num = nums[right];
            sum += num;
            while sum >= target{
                res = min(res, (right - left + 1) as i32);
                sum -= nums[left];
                left += 1;
            }
        }

        if res == nums.len() as i32 + 1 {
            return 0;
        }
        return res;
    }
}

【Leetcode-Rust】重复的DNA序列(0187)

发表于 2022-06-11 分类于 Leetcode 本文字数： 389 阅读时长 ≈ 1 分钟

题目

DNA 序列由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。

例如，"ACGAATTCCG" 是一个 DNA 序列，在研究 DNA 时，识别 DNA 中的重复序列非常有用。

给定一个表示 DNA 序列的字符串 s ，返回所有在 DNA 分子中出现不止一次的长度为 10 的序列(子字符串)。你可以按任意顺序返回答案。

示例

示例 1：

输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出：["AAAAACCCCC","CCCCCAAAAA"]

示例 2：

输入：s = "AAAAAAAAAAAAA"
输出：["AAAAAAAAAA"]

提示：

0 <= s.length <= 105
s[i]=='A'、'C'、'G' or 'T'

解法一

暴力解法，双层循环比较，结果可想而知，超时。

struct Solution;

impl Solution {
    pub fn find_repeated_dna_sequences(s: String) -> Vec<String> {
        let sub_strlen = 10;

        if s.len() <= sub_strlen {
            return vec![];
        }

        let s = s.into_bytes();
        let end = s.len() - 10;
        let mut set = std::collections::HashSet::new();

        for i in 0..=end {
            let tmp1 = &s[i..i + (sub_strlen as usize)];
            for j in (i + 1)..=end {
                let tmp2 = &s[j..j + (sub_strlen as usize)];
                if tmp2 == tmp1 {
                    unsafe {
                        set.insert(String::from_utf8_unchecked(tmp1.to_vec()));
                    }
                }
            }
        }
        set.into_iter().collect()
    }
}

fn main() {
    let dna = "AAAAAAAAAAAAA".to_owned();
    println!("{:?}", Solution::find_repeated_dna_sequences(dna));
}

解法二

O(n) 的时间复杂度，一次遍历将长度为 10 的所有子串放在 map 中，并且计数，最后将出现次数大于 1 的子串找出来返回。

use std::collections::HashMap;

struct Solution;

impl Solution {
    pub fn find_repeated_dna_sequences(s: String) -> Vec<String> {
        let sub_strlen = 10;

        if s.len() <= sub_strlen {
            return vec![];
        }

        let s = s.into_bytes();
        let end = s.len() - 10;
        let mut result = HashMap::new();

        for i in 0..=end {
            let tmp1 = &s[i..i + (sub_strlen as usize)];
            let tmp1 = unsafe { String::from_utf8_unchecked(tmp1.to_vec()) };
            result
                .entry(tmp1)
                .and_modify(|count| *count = *count + 1)
                .or_insert(1);
        }

        let result: HashMap<&String, &i32> =
            result.iter().filter(|(_, count)| **count > 1).collect();

        let result = result
            .into_keys()
            .map(|key| key.to_owned())
            .collect::<Vec<String>>();

        result
    }
}

fn main() {
    let dna = "AAAAAAAAAAAAA".to_owned();
    println!("{:?}", Solution::find_repeated_dna_sequences(dna));
}

MichaelFu

【Rust】二进制体积减小

代码优化

Docker 磁盘占用空间清理

【Rust】使用Cross进行跨平台编译

【multipass】跨平台虚拟机

Nginx

环境准备

Nginx 的主要应用场景

设计模式

SOLID 设计原则

单一职责原则（`SRP`）

面向对象

【Leetcode-Rust】长度最小的子数组(0209)

题目

示例

思路

【Leetcode-Rust】重复的DNA序列(0187)

题目

示例

解法一

解法二

代码优化

环境准备

Nginx 的主要应用场景

单一职责原则（SRP）

示例

思路

示例

解法一

解法二

单一职责原则（`SRP`）