Android-常用ADB命令与工具类

整理一下之前工作中用到的GRPC相关内容




# grpc定义

grpc是一种接口描述协议，我们可以通过定义proto文件来自动实现相关代码逻辑，举个例子：

```bash
syntax = "proto3";

// 标记所属包名
package grpc_test;
// 标记生成的go代码目录：即生成代码后会把代码文件丢到当前目录下的grpc_test文件夹中（如果是java-grpc，则是java_package)
option go_package = "./grpc_test";

// 可以把这个messsage理解为结构体定义，这个message映射为代码类或实体结构体，这里的=1和=2是在标记这个字段，从1开始，第几个字段标记为几
message GrpcHelloWorldReq {
    string message = 1;
    // 可以定义string list
    repeated string messageList = 2;
}

message GrpcHelloWorldResp {
    string message = 1;
    // 可以定义结构体list
    repeated GrpcHelloWorldReq req = 2;
}

service MeetingDeviceService {
    rpc HelloWorld(GrpcHelloWorldReq) returns (GrpcHelloWorldResp){}
    // 定义一个rpc接口，输入GrpcHelloWorldReq结构体，返回GrpcHelloWorldResp
}

```

# 代码生成
在proto文件目录下运行下面的指令
```bash
protoc --go_out=. *.proto
protoc --go-grpc_out=. *.proto    
```

成功运行后你就会在目录/grpc_test/下看到.pb.go的文件，这个里面包含了根据定义的proto文件生成的代码

# 接口实现

服务端：
```go
package main

import (
	"context"
	"fmt"
	"net"

	"kafka-test/main/grpc_test"

	"google.golang.org/grpc"
)

type server struct {
	grpc_test.MeetingDeviceServiceServer
}

func (s *server) HelloWorld(ctx context.Context, req *grpc_test.GrpcHelloWorldReq) (*grpc_test.GrpcHelloWorldResp, error) {
	fmt.Println("request:", req.Message)
	return &grpc_test.GrpcHelloWorldResp{Message: "hello " + req.Message}, nil
}

func main() {
	listen, err := net.Listen("tcp", ":8001")
	if err != nil {
		fmt.Printf("failed to listen: %v", err)
		return
	}
	s := grpc.NewServer()
	//reflection.Register(s)

	defer func() {
		s.Stop()
		listen.Close()
	}()

	fmt.Println("Serving 8001...")
	err = s.Serve(listen)
	if err != nil {
		fmt.Printf("failed to serve: %v", err)
		return
	}
}
```
客户端：
```go
package main

import (
	"context"
	"fmt"
	"sync"

	"kafka-test/main/grpc_test"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

var (
	meetingRoomRpcClient grpc_test.MeetingDeviceServiceClient
	once                 = sync.Once{}
)

func init() {
	var serviceHost = "127.0.0.1:8001"

	conn, err := grpc.Dial(serviceHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		fmt.Println(err)
	}
	defer conn.Close()
	// 初始化client（这里client作为调用方，所以只需要初始化一次）
	once.Do(func() {
		meetingRoomRpcClient = grpc_test.NewMeetingDeviceServiceClient(conn)
		//meetingRoomRpcClient = grpc_test.NewMeetingDeviceServiceClient("meeting-device-service")
	})

}

func RpcHellWorld() {
	worldResp, err := meetingRoomRpcClient.HelloWorld(context.Background(), &grpc_test.GrpcHelloWorldReq{
		Message:     "hello world",
		MessageList: []string{"hello world", "hello world"},
	})
	if err != nil {
		return
	}
	fmt.Println(worldResp.Message)
}
```

启动服务后，rpc服务会运行在本地的8001端口，因此作为下游客户端的rpc服务只需要监听这个8001端口即可实现rpc调用。当然，下游的rpc客户端服务也可以定义自己的proto rpc文件，然后被其他服务调用自己的rpc方法。

在rpc服务调用过程中，谁提供方法接口，谁是server，谁调用方法接口，谁是client，只是一个相对概念。


# 进阶——服务发现ETCD

当RPC服务多了以后，我们需要配置每个RPC服务的IP和端口，非常麻烦，因此这就需要用到注册中心来简化RPC服务管理。用注册中心的话，我们只需要记住每个服务的服务名即可，就不用再挨个记IP了。

放一个官方文档：https://etcd.io/docs/v3.5/quickstart/
安装请自行参考官方文档

ETCD注册服务端：

```golang

import (
	"context"
	"flag"
	"fmt"
	"net"
	"time"

	grpc_test2 "kafka-test/rpc/grpc_test"

	// etcd
	eclient "go.etcd.io/etcd/client/v3"
	"go.etcd.io/etcd/client/v3/naming/endpoints"
	"google.golang.org/grpc"
)

const (
	// grpc 服务名
	GrpcTestServiceName = "umb/grpc-test"
	// etcd 端口
	ETCD_ADDR = "http://localhost:2379"
)

type server struct {
	grpc_test2.UnimplementedGrpcHelloWorldServiceServer
}

func (s *server) HelloWorld(ctx context.Context, req *grpc_test2.GrpcHelloWorldReq) (*grpc_test2.GrpcHelloWorldResp, error) {
	fmt.Println("request:", req.Message)
	return &grpc_test2.GrpcHelloWorldResp{Message: "hello " + req.Message}, nil
}

func registerEndPointToEtcd(ctx context.Context, addr string) {
	// 创建 etcd 客户端
	etcdClient, _ := eclient.NewFromURL(ETCD_ADDR)
	etcdManager, _ := endpoints.NewManager(etcdClient, GrpcTestServiceName)

	// 创建一个租约，每隔 10s 需要向 etcd 汇报一次心跳，证明当前节点仍然存活
	var ttl int64 = 10
	lease, _ := etcdClient.Grant(ctx, ttl)

	// 添加注册节点到 etcd 中，并且携带上租约 id
	_ = etcdManager.AddEndpoint(ctx, fmt.Sprintf("%s/%s", GrpcTestServiceName, addr), endpoints.Endpoint{Addr: addr}, eclient.WithLease(lease.ID))

	// 每隔 5 s进行一次延续租约的动作
	for {
		select {
		case <-time.After(5 * time.Second):
			// 续约操作
			resp, _ := etcdClient.KeepAliveOnce(ctx, lease.ID)
			fmt.Printf("keep alive resp: %+v", resp)
		case <-ctx.Done():
			return
		}
	}
}

func InitRpcServer() {
	var port int
	flag.IntVar(&port, "port", 8001, "port")
	flag.Parse()
	addr := fmt.Sprintf("http://localhost:%d", port)
	listen, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Printf("failed to listen: %v", err)
		return
	}
	s := grpc.NewServer()
	//reflection.Register(s)
	grpc_test2.RegisterGrpcHelloWorldServiceServer(s, &server{})
	defer func() {
		s.Stop()
		listen.Close()
	}()
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// 注册 grpc 服务节点到 etcd 中
	go registerEndPointToEtcd(ctx, addr)
	fmt.Println("Serving 8001...")
	err = s.Serve(listen)
	if err != nil {
		fmt.Printf("failed to serve: %v", err)
		return
	}
}
```


ETCD注册客户端：

```golang
import (
	"context"
	"fmt"
	"sync"

	grpc_test2 "kafka-test/rpc/grpc_test"

	// etcd
	eclient "go.etcd.io/etcd/client/v3"
	eresolver "go.etcd.io/etcd/client/v3/naming/resolver"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

var (
	meetingRoomRpcClient grpc_test2.GrpcHelloWorldServiceClient
	once                 = sync.Once{}
)

func init() {
	// 创建 etcd 客户端
	etcdClient, _ := eclient.NewFromURL(ETCD_ADDR)

	// 创建 etcd 实现的 grpc 服务注册发现模块 resolver
	etcdResolverBuilder, _ := eresolver.NewBuilder(etcdClient)

	// 拼接服务名称，需要固定义 etcd:/// 作为前缀
	etcdTarget := fmt.Sprintf("etcd:///%s", GrpcTestServiceName)

	// 创建 grpc 连接代理
	conn, _ := grpc.Dial(
		// 服务名称
		etcdTarget,
		// 注入 etcd resolver
		grpc.WithResolvers(etcdResolverBuilder),
		// 声明使用的负载均衡策略为 roundrobin     grpc.WithDefaultServiceConfig(fmt.Sprintf(`{"LoadBalancingPolicy": "%s"}`, roundrobin.Name)),
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	defer conn.Close()
	defer conn.Close()
	// 初始化client（这里client作为调用方，所以只需要初始化一次）
	once.Do(func() {
		meetingRoomRpcClient = grpc_test2.NewGrpcHelloWorldServiceClient(conn)
		//meetingRoomRpcClient = grpc_test.NewMeetingDeviceServiceClient("meeting-device-service")
	})

}

func RpcHellWorld() {
	worldResp, err := meetingRoomRpcClient.HelloWorld(context.Background(), &grpc_test2.GrpcHelloWorldReq{
		Message:     "hello world",
		MessageList: []string{"hello world", "hello world"},
	})
	if err != nil {
		return
	}
	fmt.Println(worldResp.Message)
}
```

这样基于ETCD改造之后，server和客户端只需要知道对方的名称就能用了

Go-快速使用Grpc

# 前置准备
安装kafka-sarama库

直接附带我的go mod：

```go
require (
	github.com/IBM/sarama v1.45.0
	github.com/xdg/scram v1.0.5
	go.uber.org/zap v1.27.0
)

require (
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/eapache/go-resiliency v1.7.0 // indirect
	github.com/eapache/go-xerial-snappy v0.0.0-20230731223053-c322873962e3 // indirect
	github.com/eapache/queue v1.1.0 // indirect
	github.com/golang/snappy v0.0.4 // indirect
	github.com/hashicorp/errwrap v1.1.0 // indirect
	github.com/hashicorp/go-multierror v1.1.1 // indirect
	github.com/hashicorp/go-uuid v1.0.3 // indirect
	github.com/jcmturner/aescts/v2 v2.0.0 // indirect
	github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
	github.com/jcmturner/gofork v1.7.6 // indirect
	github.com/jcmturner/gokrb5/v8 v8.4.4 // indirect
	github.com/jcmturner/rpc/v2 v2.0.3 // indirect
	github.com/klauspost/compress v1.17.11 // indirect
	github.com/pierrec/lz4/v4 v4.1.22 // indirect
	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
	github.com/xdg/stringprep v1.0.3 // indirect
	go.uber.org/multierr v1.10.0 // indirect
	golang.org/x/crypto v0.32.0 // indirect
	golang.org/x/net v0.34.0 // indirect
	golang.org/x/text v0.21.0 // indirect
)

```

# XDGSCRAM 解密

```go

import (
	"crypto/sha256"
	"crypto/sha512"

	"github.com/xdg/scram"
)

var (
	// SHA256 ...
	SHA256 scram.HashGeneratorFcn = sha256.New
	// SHA512 ...
	SHA512 scram.HashGeneratorFcn = sha512.New
)

// XDGSCRAMClient ...
type XDGSCRAMClient struct {
	*scram.Client
	*scram.ClientConversation
	scram.HashGeneratorFcn
}

// Begin ...
func (x *XDGSCRAMClient) Begin(userName, password, authzID string) (err error) {
	x.Client, err = x.HashGeneratorFcn.NewClient(userName, password, authzID)
	if err != nil {
		return err
	}
	x.ClientConversation = x.Client.NewConversation()
	return nil
}

// Step ...
func (x *XDGSCRAMClient) Step(challenge string) (response string, err error) {
	response, err = x.ClientConversation.Step(challenge)
	return
}

// Done ...
func (x *XDGSCRAMClient) Done() bool {
	return x.ClientConversation.Done()
}

```

# 消费者接入：
```go
package main

import (
	"context"
	"log"
	"os"
	"os/signal"
	"sync"
	"syscall"

	"github.com/IBM/sarama"
)

type Kafka struct {
	brokers           []string
	topics            []string
	startOffset       int64
	version           string
	ready             chan bool
	group             string
	channelBufferSize int
	assignor          string
}

var assignor = "range"
var topics = []string{"your_topic"} // topic
var group = "consumer_group" // 订阅消费组
var user = "user" // sarma用户
var password = "pwd"  // sarama 密码
var brokers = []string{"127.0.0.1:6279"} // 你的kafka host

func NewKafka() *Kafka {
	return &Kafka{
		brokers:           brokers,
		topics:            topics,
		group:             group,
		channelBufferSize: 1000,
		ready:             make(chan bool),
		assignor:          assignor,
	}
}

func (k *Kafka) Connect() func() {
	log.Println("kafka init...")
	config := sarama.NewConfig()
	config.Version = sarama.V2_4_1_0 // 版本号必须注意要同步，否则会报错
	// 分区分配策略
	switch assignor {
	case "sticky":
		config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategySticky
	case "roundrobin":
		config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRoundRobin
	case "range":
		config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRange
	default:
		log.Panicf("Unrecognized consumer group partition assignor: %s", assignor)
	}
	config.Consumer.Offsets.Initial = sarama.OffsetNewest
	config.ChannelBufferSize = k.channelBufferSize // channel长度
	config.Consumer.Offsets.Initial = sarama.OffsetOldest
	config.Consumer.Group.Rebalance.Strategy = sarama.BalanceStrategyRoundRobin
	config.Net.SASL.Enable = true
	config.Net.SASL.User = user
	config.Net.SASL.Password = password
	config.Net.SASL.Handshake = true
	config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient {
		return &XDGSCRAMClient{HashGeneratorFcn: SHA256}
	}
	config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA256
	// 创建client
	log.Println("brokers: ", brokers)
	newClient, err := sarama.NewClient(brokers, config)
	if err != nil {
		log.Fatalf("Error creating client: %v", err)
	}
	// 获取所有的topic
	topics, err := newClient.Topics()
	if err != nil {
		log.Fatal(err)
	}
	log.Println("topics: ", topics)

	// 根据client创建consumerGroup
	client, err := sarama.NewConsumerGroupFromClient(k.group, newClient)
	if err != nil {
		log.Fatalf("Error creating consumer group client: %v", err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	wg := &sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			if err := client.Consume(ctx, k.topics, k); err != nil {
				// 当setup失败的时候，error会返回到这里
				log.Println("Error from consumer: %v", err)
				return
			}
			// check if context was cancelled, signaling that the consumer should stop
			if ctx.Err() != nil {
				log.Println(ctx.Err())
				return
			}
			k.ready = make(chan bool)
		}
	}()
	<-k.ready
	log.Println("Sarama consumer up and running!...")
	// 保证在系统退出时，通道里面的消息被消费
	return func() {
		log.Println("kafka close")
		cancel()
		wg.Wait()
		if err = client.Close(); err != nil {
			log.Println("Error closing client: %v", err)
		}
	}
}

// Setup is run at the beginning of a new session, before ConsumeClaim
func (k *Kafka) Setup(session sarama.ConsumerGroupSession) error {
	log.Println("setup")
	session.ResetOffset("lvmi", 0, 13, "")
	log.Println(session.Claims())
	// Mark the consumer as ready
	close(k.ready)
	return nil
}

// Cleanup is run at the end of a session, once all ConsumeClaim goroutines have exited
func (k *Kafka) Cleanup(sarama.ConsumerGroupSession) error {
	log.Println("cleanup")
	return nil
}

// ConsumeClaim must start a consumer loop of ConsumerGroupClaim's Messages().
func (k *Kafka) ConsumeClaim(session sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error {

	// NOTE:
	// Do not move the code below to a goroutine.
	// The `ConsumeClaim` itself is called within a goroutine, see:
	// https://github.com/Shopify/sarama/blob/master/consumer_group.go#L27-L29
	// 具体消费消息
	for message := range claim.Messages() {
		log.Printf("[topic:%s] [partiton:%d] [offset:%d] [value:%s] [time:%v]",
			message.Topic, message.Partition, message.Offset, string(message.Value), message.Timestamp)
		// 更新位移
		session.MarkMessage(message, "")
	}
	return nil
}

func main() {
	k := NewKafka()
	c := k.Connect()

	sigterm := make(chan os.Signal, 1)
	signal.Notify(sigterm, syscall.SIGINT, syscall.SIGTERM)
	select {
	case <-sigterm:
		log.Println("terminating: via signal")
	}
	c()
}
```

Go 接入sarama认证的Kafka

# 2024-时间线



* ### 1月：新年

一月初人在上海，恰好赶上跨年，比较幸运在八角场线下参加了B站的跨年夜活动

当时拍的照片：

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

在上海和朋友夹了娃娃，非常幸运，夹了一大坨


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

月末高中的兄弟来北京玩，一起去了颐和园（高糊画质）


![5853d864655344cefb37386245b2e528.png](/static/img/54f66d03995012893d1b2637054b5d41.5853d864655344cefb37386245b2e528.webp)

* ### 2月：过年

难得回家休息，拼了从上海带回来的自由高达：


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


![4ABC18269B32CB206D5CB3B5F60679D5.png](/static/img/613c79ec8f7e1112a75e69b818e2828a.4ABC18269B32CB206D5CB3B5F60679D5.webp)

过年最重要的事情当然是几个街溜子在午夜放烟花


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

年后陪家人去了古县城（这里真的安利太原古县城）

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

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

年后临近返工，获知了一位朋友将要订婚的消息，都非常开心，也是突然发现，原来大家要到谈婚论嫁的年纪了，原来大家已经不再是小孩了。

年后返工，遇上倒春寒，下雪的西二旗


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

* ### 3月：家庭新成员

3月，家庭新加入了新成员——GC，一直两周大的银渐层小猫（非常可爱！！！）

刚到家就往马桶钻的GC：那个时候还很瘦

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

现在的GC：

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

* ### 4月：樱花

4月小区里的樱花宛如动漫场景，美不胜收，每天出门就是一个享受


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

* ### 5月 晚霞

平平无奇的五月，被某天的晚霞打破了原本的乏味


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

* ### 6月：搬家

被赶出家门，被迫搬家。因为上个房东不愿意出租了，被迫搬离了住了大半年的家，自如赔了点钱，但是还不够补贴差价的=.=。
附一张六月的GC
![image.png](/static/img/564ed7e350526e5132a226378c417c15.image.webp)
* ### 7月：演唱会！

7月初，临近入职一周年，获得了公司发的奖章！好诶！

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

7月中，回家呆了几天。突然感觉人都是很脆弱的，可能不觉中某个人就不在了，顿感生命脆弱，也是在这个时候突然发现，我到了要承担家庭重大事项的年纪。

七月末，未来有你——初音未来演唱会！！！

带着曾经实验室的棒子——来自某位热情学弟赞助

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


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

非常棒的演唱会企划展：

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

![image.png](/static/img/7b3bf425216af2379dd0ec35b947c003.image.webp)
非常好的法披（狠狠爆了金币）

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

因为快手买了冠名，所以这次请了蔡萝莉在现场站台cos：


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


小插曲：


我完成了我的桌搭升级！

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

* ### 8月： 旅游！开发者大会


-  8月初，抓着月初的簪头，和好兄弟说走就走的周末极限苏州行

拙政园的街道：

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

七里山塘：

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

西园寺：


![image.png](/static/img/0c10261dd19e733de7c8af2a5a4fc7e6.image.webp)
附一张帅气的我好哥们（单身，在线招亲）博主本人长相很一般，且严重社恐，就不献丑了。

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


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

还有苏州大裤衩

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

金鸡湖偶遇的小情侣，这张是我抓拍的，非常有氛围感

![066DC899A1387E285C185D1E07D8C463.png](/static/img/e91e51462b38efcc287c4c0c63dbde8d.066DC899A1387E285C185D1E07D8C463.webp)

凌晨极限跑到了杭州，进行杭州半日游：
西湖旁边的凌晨客栈一角：
![](https://umb.ink/static/img/f218e3688d890b0091c4e3861fed1ceb.image.webp)

看到了雷锋塔
![image.png](/static/img/5dc565c021abdc2531c0a89a918d0871.image.webp)

某个周末，在北京王府井看到了高达

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

- 8月中：谷歌开发者大会！


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

世界各地有趣的开发团队：


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

- 出发！四川黄龙与九寨沟

公司团队团建，我们来到了黄龙与九寨景区
黄龙：
![image.png](/static/img/f1ff32d9c3083eaae4bbb23aa4c8a1ea.image.webp)

九寨沟：九寨归来不看水，是真的美


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

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

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

山也很美：


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

藏民的白塔印象也很深


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

最后一天去了成都天府红，死宅天堂：


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

- ### 9月：游戏

黑神话8.20上线便引爆了国内游戏圈，趁热九月我也进行了高强度开干。不得不说黑神话悟空真是一件值得被称为艺术品的游戏。
可惜没有那么强的肝，最后也只是通关了三周目，没有做到全成就。
![image.png](/static/img/8284bf527f2aac7cdf7c119f50a19fb3.image.webp)

- ### 10月：国庆，故地重游，演唱会！！！！

趁着放假，连夜回到了太原，非常好看的太原迎泽大桥，满满的红色浪漫

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

回到了学校，仅仅一年变得如此气派，震惊了我，差点以为走错了学校。果然是人类定则：毕业后母校马上变样

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

* 10月4日，期盼了10年的洛天依演唱会！！！

我从刚上初中那会就喜欢听洛天依的歌，从前尘入梦入坑，被这个纯虚拟的少女歌声吸引，逐渐了解了V家、调教、编程、建模等很多东西，洛天依出现在我的生活中，我也多少受影响才走上了计算机的道路。

第一次在现场，听到上山岗的时候，听哭了。
![image.png](/static/img/458a60d7b1c0fc6a9836d47a576d538d.image.webp)
![image.png](/static/img/6adba0ca9cc1152b220e22fc58768c45.image.webp)
附近的企划展，也特别好逛（狠狠给禾念爆金币）：
![image.png](/static/img/b8e8da98a59da5acdc657b0298502e56.image.webp)
![image.png](/static/img/7c7c46f5a6f620adad626624598fe6ad.image.webp)

到家后的战利品：

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

* 10月20 —— 给学弟学妹分享

实验室之前的学弟学妹在10月中突然邀请我回去给大家分享一些关于大学和就业规划的事情，借着实验室新一批纳新的机会，也比较有幸给大家分享了一些我自己的经历。

![39b93f4b881a0095ca93818d0046e508.jpeg](/static/img/fb139466360b086b024813b815f9f25e.39b93f4b881a0095ca93818d0046e508.webp)
* ### 11月 总决赛以及加班加班还是加班
11.2是LOL 全球总决赛的日子，公司社团组织了线下观影活动，去现场看了比赛，虽然结果BLG惜败，但依然值得铭记。

依然记得穿着RNG队服去伦敦现场看BLG的哥们
![image.png](/static/img/63c0d1b91073f913497245e49b94a27d.image.webp)

* 临近年底，团队内追赶项目交付，开始了封闭开发的生活，11月经常连明昼夜地干活，不觉一月就过去了。
* ### 12月 加班加班

更临近交付日期了，还是加班。

2024-时间线

# 起因
之前一直在用腾讯云提供的免费SSL证书，但是从今年年中以来，腾讯云停止了免费签发一年期的SSL证书，而是必须用它给的三个月有效期的证书，非常的恶心人。

因此，转而考虑使用Let's Encrypt签发的免费SSL证书，彻底干掉愚蠢的国内供应商提供的证书。



# 配置

在开始之前，请确保你服务器的80端口可以正常访问，并安装了nginx（当然也可以不用nginx，用caddy或者其他的请另寻教程）

另外在你的域名服务提供商那里配置DNS A记录解析到要配置证书的服务器上面

在配置时关闭CDN访问！否则验证会失败！

# 使用certbot

## 在你的linux服务器上安装certbot
```
apt install certbot
```
## 配置证书

-d后面跟你的域名即可

````
 certbot --nginx -d umb.ink
````

如果遇到Saving debug log to /var/log/letsencrypt/letsencrypt.logThe requested nginx plugin does not appear to be installed的报错，如下图：


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

则安装python3-certbot-nginx即可，`sudo apt install python3-certbot-nginx`

完成后继续运行最上面的配置证书指令，按照提示配置你的邮箱、并选择同意


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


如果遇到Challenge failed for domain 的报错， 检查你的服务器80端口是否可以正常访问！包括但不限于防火墙、端口占用等。
![image.png](/static/img/25b5e8ca2dcd60d729c43fcd5ae11706.image.webp)

成功配置后：


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


此时从浏览器外网访问你的域名，就可以看到证书了



配置很简单，并且完全免费，配置只需要几行指令，很省事，是非常好的文明