## A nice cheat sheet of different cloud services (2023 edition)




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


## What is cloud native?
Below is a diagram showing the evolution of architecture and processes since the 1980s.


![image.png](/static/img/0258b78c20140da788a6f12885ed7834.image.webp)

组织可以使用云原生技术在公共云、私有云和混合云上构建和运行可扩展的应用程序。

这意味着应用程序被设计为利用云特性，因此它们能够抵御负载并易于扩展。

云原生包括4个方面：

1. 开发过程：这个过程已经从瀑布式发展到敏捷再到DevOps。

2. 应用程序架构: 架构已经从单体发展到微服务。每个服务都被设计得很小，适应云容器中的有限资源。

3. 部署和打包:  应用程序过去通常部署在物理服务器上。然后在2000年左右，对延迟不敏感的应用程序通常部署在虚拟服务器上。对于云原生应用程序，它们被打包成Docker镜像并部署在容器中。

4. 应用程序基础设施: 应用程序大量部署在云基础设施上，而不是自托管服务器上。

10 Cloud Services

## How Git Commands work

To begin with, it's essential to identify where our code is stored. The common assumption is that there are only two locations - one on a remote server like Github and the other on our local machine. However, this isn't entirely accurate. Git maintains three local storages on our machine, which means that our code can be found in four places:





![image.png](/static/img/9dc574e95d3152d66e3b4b1d407b427e.image.webp)

* 工作目录：我们编辑文件的地方
* 暂存区：一个临时位置，用于保存下一次提交的文件
* 本地仓库：包含已提交代码的地方
* 远程仓库：存储代码的远程服务器

大多数Git命令主要在这四个位置之间移动文件。


## How does Git Work?

![image.png](/static/img/4bfecfd3b4d0eda2679da46fa4901b48.image.webp)

Git是一个分布式版本控制系统。

每个开发人员都维护主仓库的本地副本，并在本地副本上进行编辑和提交。

提交操作非常快，因为该操作不与远程仓库进行交互。

如果远程仓库崩溃，可以从本地仓库恢复文件。


## Git merge vs. Git rebase

What are the differences?


![image.png](/static/img/0dc127b9730f39fe9e0d1b70832db907.image.webp)

当我们从一个Git分支合并更改到另一个分支时，我们可以使用“git merge”或“git rebase”。下面的图表显示了这两个命令的工作原理。

>Git合并

这会在主分支中创建一个新的提交G'。G'将主分支和功能分支的历史联系起来。

Git合并是非破坏性的。主分支和功能分支都不会改变。

> Git变基

Git变基将功能分支历史移动到主分支的头部。它为功能分支中的每个提交创建新的提交E'、F'和G'。

变基的好处是它有一个线性的提交历史。

如果不遵循“git rebase的黄金法则”，变基可能会很危险。

>Git Rebase的黄金法则

永远不要在对公共分支使用它！

09 Git

## DevOps vs. SRE vs. Platform Engineering. What is the difference?

DevOps、SRE和平台工程的概念在不同时期出现，并由不同的个人和组织发展而来。




![image.png](/static/img/49b8ad81967ba5cc8a32d6e8e23b7837.image.webp)

DevOps作为一个概念是由Patrick Debois和Andrew Shafer在2009年的敏捷会议上提出的。他们试图通过促进协作文化和对整个软件开发生命周期的共同责任来弥合软件开发与运营之间的鸿沟。

SRE，即站点可靠性工程，是由谷歌在21世纪初为解决管理大规模复杂系统的运营挑战而开创的。谷歌开发了SRE实践和工具，如Borg集群管理系统和Monarch监控系统，以提高其服务的可靠性和效率。

平台工程是一个较新的概念，建立在SRE工程的基础上。平台工程的精确起源不太清楚，但它通常被认为是对DevOps和SRE实践的扩展，专注于为产品开发提供一个全面的平台，支持整个业务视角。

值得注意的是，虽然这些概念在不同的时间出现，但它们都与改进软件开发与运营中的协作、自动化和效率的更广泛趋势有关。


## What is k8s (Kubernetes)?

K8s is a container orchestration system. It is used for container deployment and management. Its design is greatly impacted by Google’s internal system Borg.

![image.png](/static/img/7958105618b5335ae6370937b243a0da.image.webp)

一个k8s集群由一组工作机器组成，称为节点，它们运行容器化应用程序。每个集群至少有一个工作节点。

工作节点承载Pod，这是应用程序工作负载的组成部分。控制平面管理集群中的工作节点和Pod。在生产环境中，控制平面通常在多台计算机上运行，并且一个集群通常运行多个节点，提供容错和高可用性。

>控制平面组件
1. API服务器: API服务器与k8s集群中的所有组件通信。对Pod的所有操作都是通过与API服务器通信执行的。

2. 调度器: 调度器监视Pod工作负载并分配新创建的Pod上的负载。

3. 控制器管理器 :控制器管理器运行控制器，包括节点控制器、作业控制器、EndpointSlice控制器和ServiceAccount控制器。

4. Etcd: etcd是一个键值存储，用作Kubernetes所有集群数据的后端存储。

> 节点
 
1. Pods: Pod是一组容器，是k8s管理的最小单位。Pod具有一个IP地址，应用于Pod内的每个容器。

2. Kubelet: 一个在集群的每个节点上运行的代理。它确保容器在Pod中运行。

3. Kube Proxy: Kube-proxy是运行在集群每个节点上的网络代理。它将来自服务的流量路由到节点。它将工作请求转发到正确的容器。

## Docker vs. Kubernetes. Which one should we use?

![image.png](/static/img/5377c2bc5b7e9b4fcf3938f5d20c6bd4.image.webp)

Docker是一个开源平台，允许您将应用程序打包、分发并在隔离的容器中运行。它专注于容器化，提供轻量级环境，封装应用程序及其依赖关系。

Kubernetes，通常被称为K8s，是一个开源容器编排平台。它提供了一个框架，用于自动化跨节点集群的容器化应用程序的部署、扩展和管理。

两者之间的区别在于：

* Docker：Docker在单个操作系统主机上的单个容器级别运行。您必须手动管理每个主机，并为多个相关容器设置网络、安全策略和存储可能会很复杂。
* Kubernetes：Kubernetes在集群级别运行。它管理跨多个主机的多个容器化应用程序，为负载平衡、扩展和确保应用程序所需状态等任务提供自动化。

简而言之，Docker专注于容器化和在单个主机上运行容器，而Kubernetes专门负责跨主机集群管理和编排容器。


## How does Docker work?
The diagram below shows the architecture of Docker and how it works when we run “docker build”, “docker pull” and “docker run”.


![image.png](/static/img/5faa8c6bbf1d762fe2a1dc430786ce66.image.webp)
Docker架构中有3个组件：

1. Docker客户端：Docker客户端与Docker守护进程通信。
2. Docker主机： Docker守护进程监听Docker API请求并管理Docker对象，如镜像、容器、网络和卷。
3. Docker注册表： Docker注册表存储Docker镜像。Docker Hub是一个任何人都可以使用的公共注册表。

让我们以“docker run”命令为例。

1. Docker从注册表中拉取镜像。
2. Docker创建一个新容器。
3. Docker为容器分配一个读写文件系统。
4. Docker创建一个网络接口，将容器连接到默认网络。
5. Docker启动容器。

08 DevOps

## How to learn payment systems?



![image.png](/static/img/82cac64b721c623bb9fac0667d773a04.image.webp)

## Why is the credit card called “the most profitable product in banks”? How does VISA/Mastercard make money?

The diagram below shows the economics of the credit card payment flow.


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

翻译：

1. 持卡人向商家支付100美元购买产品。

2. 商家通过使用信用卡获得更高的销售额，并需要补偿发卡机构和卡网络提供的支付服务。收单银行与商家设定一个费用，称为“商户折扣费”。

3-4. 收单银行保留0.25美元作为收单利润，而1.75美元支付给发卡银行作为交换费。商户折扣费应覆盖交换费。

交换费由卡网络设定，因为每个发卡银行与每个商家协商费用效率较低。

5. 卡网络与每家银行设定网络评估和费用，银行每月为其服务向卡网络支付费用。例如，VISA每次刷卡收取0.11%的评估费，加上0.0195美元的使用费。

6. 持卡人为发卡银行的服务付费。

> 为什么发卡银行应该得到补偿？

即使持卡人未能支付发卡机构，发卡机构仍会支付商家。
发卡机构在持卡人支付之前先支付给商家。
发卡机构有其他运营成本，包括管理客户账户、提供账单、欺诈检测、风险管理、清算和结算等。

## How does VISA work when we swipe a credit card at a merchatn's shop?


![image.png](/static/img/2e5573c572d13ae610084014d583cae5.image.webp)

VISA、Mastercard和American Express作为卡网络参与资金的清算和结算。收单银行和发卡银行可以是不同的银行，通常也是如此。如果银行不通过中介逐一结算交易，那么每家银行都需要与其他所有银行结算交易。这非常低效。

下图显示了VISA在信用卡支付过程中的作用。涉及两个流程。授权流程发生在客户刷卡时。捕获和结算流程发生在商家在一天结束时想要收款时。

授权流程
* 步骤0：发卡银行向其客户发放信用卡。
* 步骤1：持卡人想要购买产品，并在商家的销售点（POS）终端刷卡。
* 步骤2：POS终端将交易发送给提供POS终端的收单银行。
* 步骤3和4：收单银行将交易发送给卡网络，也称为卡计划。卡网络将交易发送给发卡银行以获取批准。
* 步骤4.1、4.2和4.3：如果交易获得批准，发卡银行冻结资金。批准或拒绝信息被发送回收单银行以及POS终端。

捕获和结算流程
* 步骤1和2：商家在一天结束时想要收款，因此在POS终端上点击“捕获”。交易批量发送给收单银行。收单银行将包含交易的批文件发送给卡网络。
* 步骤3：卡网络对从不同收单银行收集的交易进行清算，并将清算文件发送给不同的发卡银行。
* 步骤4：发卡银行确认清算文件的正确性，并将资金转账给相关的收单银行。
* 步骤5：收单银行然后将资金转账给商家的银行。
* 步骤4：卡网络清理来自不同收单银行的交易。清算是相互抵消的交易进行净额结算的过程，从而减少总交易数量。

在这个过程中，卡网络承担了与每家银行沟通的负担，并收取服务费作为回报。

## Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India

翻译：

什么是UPI？UPI是由印度国家支付公司开发的即时实时支付系统。

目前，它占印度数字零售交易的60%。

UPI = 支付标记语言 + 可互操作支付标准


![image.png](/static/img/6f256138dc0577d3ec7cb324b5fc0fe4.image.webp)

07 Payment systems

## 语法
右边是一个泛型接口，其中类型参数T可以是任务类型


![image.png](/static/img/151eadf4d3c916e9742280e5cc100410.image.webp)




结构体也可以使用泛型
```go
type LinedListV1[T any] struct {
    head *nodeV1[T]
}

func (l *LinkedListV1[T]) Add (idx int, val T) {
    //TODO implement me 
    panic("implement me")
}

func (l *LinkedListV1[T]) Append(val T){
    //TODO implement me 
    panic("implement me")
}

func (l *LinkedListV1[T]) Delete(idx T){
    //TODO implement me 
    panic("implement me ")
}

type NodeV1[T any] struct {
    data T
}

func UseList(){
    l := &LinkedListV1[int]{}
    l.Add(index: 1, val:123)
    l.Add(index: 1, val:"123") //这里会报错
}
```

方法也可以用泛型

```go
package generics

func Sum[T Number](vals []T) T{
    var res T
    for _,v :=range vals{
        res = res + v // 若sum用的是Any，就不能相加，因为数据类型可能是非数字，所以该用Number来检查
    }
    return res
}

type Integer int
type Number interface {
    int | unint
    // 或者int的衍生类型 ~int | unint
}

func UseSum(){
// 必须使用衍生类型的int
    res:=Sum[int]([]int{123, 123})
    println(res)
    resV1 := Sum[Integer]([]Integer{123,123})
    println(res)
}


func Closable[T io.Closer](){
    var t T
    t.Close()
}
```


## 代码演示
[标准实现参考](https://github.com/ecodeclub/ekit/tree/dev/slice)
### 求和
### 求最大值、最小值
```go
func Max[T Number](vals []T) T{
    t:=vals[0]
    for i :=1; i< len(vals);i++ {
        if t <vals[i]{
            t=vals[i]
            }
        }
    return t
}

func Min[T Number](vals []T) T{
    t:=vals[0]
    for i :=1; i< len(vals);i++ {
        if t >vals[i]{
            t=vals[i]
            }
        }
    return t
}

```
### 过滤和查找
```go
func Find[T any](vals []T, filter func(t T)bool) T{
    for _,v :=range vals{
        if filter(v) {
            return v
        }
    }
    var t T
    return t

}

```
### 在切片特定索引位置插入元素
```go
func Insert[T any](ids int, vals []int) {
    if idx <0 || idx >= len(vals) {
        panic("idx 不合法")
    }
    //先扩容
    vas = append(vals, val)
    for i:=len(vals)-1; i>idx; i-- {
        if i-1>=0{
            vals[i]=vals[i-1]
        }
    }
    vals[idx] = val
    return vals
}

//调用使用

package main

import "fmt"

func main(){
    fmt.Printf("%v \n", Insert[int](0, 12, []int{1,2}))
    fmt.Printf("%v \n", Insert[int](2, 12, []int{1,2}))
    fmt.Printf("%v \n", Insert[int](1, 12, []int{1,2}))
}
```