浅析Redis大Key | 京东云技术团队

一、背景

在京东到家购物车系统中,用户基于门店能够对商品进行加车操作。用户与门店商品使用Redis的Hash类型存储,如下代码块所示。不知细心的你有没有发现,如果单门店加车商品过多,或者门店过多时,此Key就会越来越大,从而影响线上业务。

userPin:{storeId:{门店下加车的所有商品基本信息},storeId:{门店下加车的所有商品基本信息},......
}

二、BigKey的界定和如何产生

2.1、BigKey的界定

BigKey称为大Key,通常以Key对应Value的存储大小,或者Key对应Value的数量来进行综合判断。对于大Key也没有严格的定义区分,针对String与非String结构,给出如下定义:

  • String:String类型的 Key 对应的 Value 超过 10KB
  • 非String结构(Hash,Set,ZSet,List):Value的数量达到10000个,或者Vaule的总大小为100KB
  • 集群中Key的总数超过1亿

2.2、如何产生

1、数据结构设置不合理,例如集合中元素唯一时,应该使用Set替换List;

2、针对业务缺少预估性,没有预见Value动态增长;

3、Key没有设置过期时间,把缓存当成垃圾桶,一直再往里面扔,但是从不处理。

三、BigKey的危害

3.1、数据倾斜

redis数据倾斜分为数据访问倾斜和**数据量倾斜,**会导致该Key所在的数据分片节点CPU使用率、带宽使用率升高,从而影响该分片上所有Key的处理。

**数据访问倾斜:**某节点中key的QPS高于其他节点中的Key

**数据量倾斜:**某节点中key的大小高于其他节点中的Key,如下图,实例1中的Key1存储高于其他实例。

3.2、网络阻塞

Redis服务器是一个事件驱动程序,有文件事件和时间事件,文件事件和时间事件都是主线程完成。其中文件事件就是服务器对套接字操作的抽象,客户端与服务端的通信会产生相应的文件事件,服务器通过监听并处理这些事件来完成一系列网络通信操作。

Redis基于Reactor模式开发了自己的网络事件处理器,即文件事件处理器,该处理器内部使用I/O多路复用程序,可同时监听多个套接字,并根据套接字执行的任务来关联不同的事件处理器。文件事件处理器以单线程的方式运行,但是通过I/O多路复用程序来监听多个套接字,既实现了高性能网络通信模型,又保持了内部单线程设计的简单性。文件事件处理器构成如下图:

文件事件是对套接字操作的抽象,包括连接应答,写入,读取,关闭,因为一个服务器会连接多个套接字,所以文件事件可能并发出现,即使文件事件并发的出现,但是I/O多路复用程序会将套接字放入一个队列,通过队列有序的,同步的每次一个套接字的方式向文件事件分派器传送套接字,当让一个套接字产生的事件被处理完毕后,I/O多路复用程序才会继续向文件事件分派器传送下一个套接字,当有大key时,单次操作时间延长,导致网络阻塞。

3.3、慢查询

严重影响 QPS 、TP99 等指标,对大Key进行的慢操作会导致后续的命令被阻塞,从而导致一系列慢查询。

3.4、CPU压力

当单Key过大时,每一次访问此Key都可能会造成Redis阻塞,其他请求只能等待了。如果应用中设置了超时等,那么上层就会抛出异常信息。最后删除的时候也会造成redis阻塞,到时候内存中数据量过大,就会造成CPU负载过高。单个分片cpu占用率过高,其他分片无法拥有cpu资源,从而被影响。此外,大 key 对持久化也有些影响。fork 操作会拷贝父进程的页表项,如果过大,会占用更多页表,主线程阻塞拷贝需要一定的时间。

四、如何检测BigKey

4.1、redis-cli --bigkeys

首先我们从运行结果出发。首先通过脚本插入一些数据到redis中,然后执行redis-cli的–bigkeys选项

$ redis-cli --bigkeys# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.01 to sleep 0.01 sec
# per SCAN command (not usually needed).
-------- 第一部分start -------
[00.00%] Biggest string found so far 'key-419' with 3 bytes
[05.14%] Biggest list   found so far 'mylist' with 100004 items
[35.77%] Biggest string found so far 'counter:__rand_int__' with 6 bytes
[73.91%] Biggest hash   found so far 'myobject' with 3 fields-------- 第一部分end --------------- summary --------------- 第二部分start -------
Sampled 506 keys in the keyspace!
Total key length in bytes is 3452 (avg len 6.82)Biggest string found 'counter:__rand_int__' has 6 bytes
Biggest   list found 'mylist' has 100004 items
Biggest   hash found 'myobject' has 3 fields
-------- 第二部分end --------------- 第三部分start -------
504 strings with 1403 bytes (99.60% of keys, avg size 2.78)
1 lists with 100004 items (00.20% of keys, avg size 100004.00)
0 sets with 0 members (00.00% of keys, avg size 0.00)
1 hashs with 3 fields (00.20% of keys, avg size 3.00)
0 zsets with 0 members (00.00% of keys, avg size 0.00)
-------- 第三部分end -------

以下我们分三步对bigkeys选项源码原理进行解析,简要流程如下图:

4.1.1、第一部分是如何进行找key的呢?

Redis找bigkey的函数是static void findBigKeys(int memkeys, unsigned memkeys_samples),因为–memkeys选项和–bigkeys选项是公用同一个函数,所以使用memkeys时会有额外两个参数memkeys、memkeys_sample,但这和–bigkeys选项没关系,所以不用理会。findBigKeys具体函数框架为:

1.申请6个变量用以统计6种数据类型的信息(每个变量记录该数据类型的key的总数量、bigkey是哪个等信息)

typedef struct {char *name;//数据类型,如stringchar *sizecmd;//查询大小命令,如string会调用STRLENchar *sizeunit;//单位,string类型为bytes,而hash为fieldunsigned long long biggest;//最大key信息域,此数据类型最大key的大小,如string类型是多少bytes,hash为多少fieldunsigned long long count;//统计信息域,此数据类型的key的总数unsigned long long totalsize;//统计信息域,此数据类型的key的总大小,如string类型是全部string总共多少bytes,hash为全部hash总共多少fieldsds biggest_key;//最大key信息域,此数据类型最大key的键名,之所以在数据结构末尾是考虑字节对齐
} typeinfo;dict *types_dict = dictCreate(&typeinfoDictType);typeinfo_add(types_dict, "string", &type_string);typeinfo_add(types_dict, "list", &type_list);typeinfo_add(types_dict, "set", &type_set);typeinfo_add(types_dict, "hash", &type_hash);typeinfo_add(types_dict, "zset", &type_zset);typeinfo_add(types_dict, "stream", &type_stream);

2.调用scan命令迭代地获取一批key(注意只是key的名称,类型和大小scan命令不返回)

/* scan循环扫描 */
do {/* 计算完成的百分比情况 */pct = 100 * (double)sampled/total_keys;//这里记录下扫描的进度/* 获取一些键并指向键数组 */reply = sendScan(&it);//这里发送SCAN命令,结果保存在reply中keys  = reply->element[1];//keys来保存这次scan获取的所有键名,注意只是键名,每个键的数据类型是不知道的。......} while(it != 0); 

3.对每个key获取它的数据类型(type)和key的大小(size)

/* 检索类型,然后检索大小*/
getKeyTypes(types_dict, keys, types);
getKeySizes(keys, types, sizes, memkeys, memkeys_samples);

4.如果key的大小大于已记录的最大值的key,则更新最大key的信息

/* Now update our stats */
for(i=0;i<keys->elements;i++) {......//前面已解析//如果遍历到比记录值更大的key时if(type->biggest<sizes[i]) {/* Keep track of biggest key name for this type */if (type->biggest_key)sdsfree(type->biggest_key);//更新最大key的键名type->biggest_key = sdscatrepr(sdsempty(), keys->element[i]->str, keys->element[i]->len);if(!type->biggest_key) {fprintf(stderr, "Failed to allocate memory for key!\n");exit(1);}//每当找到一个更大的key时则输出该key信息printf("[%05.2f%%] Biggest %-6s found so far '%s' with %llu %s\n",pct, type->name, type->biggest_key, sizes[i],!memkeys? type->sizeunit: "bytes");/* Keep track of the biggest size for this type *///更新最大key的大小type->biggest = sizes[i];}......//前面已解析
}

5.对每个key更新对应数据类型的统计信息

/* 现在更新统计数据 */
for(i=0;i<keys->elements;i++) {typeinfo *type = types[i];/* 跳过在SCAN和TYPE之间消失的键 */if(!type)continue;//对每个key更新每种数据类型的统计信息type->totalsize += sizes[i];//某数据类型(如string)的总大小增加type->count++;//某数据类型的key数量增加totlen += keys->element[i]->len;//totlen不针对某个具体数据类型,将所有key的键名的长度进行统计,注意只统计键名长度。sampled++;//已经遍历的key数量......//后续解析/* 更新整体进度 */if(sampled % 1000000 == 0) {printf("[%05.2f%%] Sampled %llu keys so far\n", pct, sampled);}
}
4.1.2、第二部分是如何执行的?

1.输出统计信息、最大key信息

   /* We're done */printf("\n-------- summary -------\n\n");if (force_cancel_loop) printf("[%05.2f%%] ", pct);printf("Sampled %llu keys in the keyspace!\n", sampled);printf("Total key length in bytes is %llu (avg len %.2f)\n\n",totlen, totlen ? (double)totlen/sampled : 0);

2.首先输出总共扫描了多少个key、所有key的总长度是多少。

/* Output the biggest keys we found, for types we did find */di = dictGetIterator(types_dict);while ((de = dictNext(di))) {typeinfo *type = dictGetVal(de);if(type->biggest_key) {printf("Biggest %6s found '%s' has %llu %s\n", type->name, type->biggest_key,type->biggest, !memkeys? type->sizeunit: "bytes");}}dictReleaseIterator(di);
4.1.3、第三部分是如何执行的?

di为字典迭代器,用以遍历types_dict里面的所有dictEntry。de = dictNext(di)则可以获取下一个dictEntry,de是指向dictEntry的指针。又因为typeinfo结构体保存在dictEntry的v域中,所以用dictGetVal获取。然后就是输出typeinfo结构体里面保存的最大key相关的数据,包括最大key的键名和大小。

  di = dictGetIterator(types_dict);while ((de = dictNext(di))) {typeinfo *type = dictGetVal(de);printf("%llu %ss with %llu %s (%05.2f%% of keys, avg size %.2f)\n",type->count, type->name, type->totalsize, !memkeys? type->sizeunit: "bytes",sampled ? 100 * (double)type->count/sampled : 0,type->count ? (double)type->totalsize/type->count : 0);}dictReleaseIterator(di);

4.2、使用开源工具发现大Key

在不影响线上服务的同时得到精确的分析报告。使用redis-rdb-tools工具以定制化方式找出大Key,该工具能够对Redis的RDB文件进行定制化的分析,但由于分析RDB文件为离线工作,因此对线上服务不会有任何影响,这是它的最大优点但同时也是它的最大缺点:离线分析代表着分析结果的较差时效性。对于一个较大的RDB文件,它的分析可能会持续很久很久。

redis-rdb-tools的项目地址为:https://github.com/sripathikrishnan/redis-rdb-tools

五、如何解决Bigkey

5.1、提前预防

  • 设置过期时间,尽量过期时间分散,防止同一时间过期;
  • 存储为String类型的JSON,可以删除不使用的Filed;

例如对象为{“userName”:“京东到家”,“ciyt”:“北京”},如果只需要用到userName属性,那就定义新对象,只具有userName属性,精简缓存中数据

  • 存储为String类型的JSON,利用@JsonProperty注解让FiledName字符集缩小,代码例子如下。但是存在缓存数据识别性低的缺点;
import org.codehaus.jackson.annotate.JsonProperty;
import org.codehaus.jackson.map.ObjectMapper;
import java.io.IOException;
public class JsonTest {@JsonProperty("u")private String userName;public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public static void main(String[] args) throws IOException {JsonTest output = new JsonTest();output.setUserName("京东到家");System.out.println(new ObjectMapper().writeValueAsString(output));String json = "{\"u\":\"京东到家\"}";JsonTest r1 = new ObjectMapper().readValue(json, JsonTest.class);System.out.println(r1.getUserName());}
}{"u":"京东到家"}
京东到家
  • 采用压缩算法,利用时间换空间,进行序列化与反序列化。同时也存在缓存数据识别性低的缺点;
  • 在业务上进行干预,设置阈值。比如用户购物车的商品数量,或者领券的数量,不能无限的增大;

5.2、如何优雅删除BigKey

5.2.1、DEL

此命令在Redis不同版本中删除的机制并不相同,以下分别进行分析:

redis_version < 4.0 版本:在主线程中同步删除,删除大Key会阻塞主线程,见如下源码基于redis 3.0版本。那针对非String结构数据,可以先通过SCAN命令读取部分数据,然后逐步进行删除,避免一次性删除大key导致Redis阻塞。

// 从数据库中删除给定的键,键的值,以及键的过期时间。
// 删除成功返回 1,因为键不存在而导致删除失败时,返回 0 
int dbDelete(redisDb *db, robj *key) {// 删除键的过期时间if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);// 删除键值对if (dictDelete(db->dict,key->ptr) == DICT_OK) {// 如果开启了集群模式,那么从槽中删除给定的键if (server.cluster_enabled) slotToKeyDel(key);return 1;} else {// 键不存在return 0;}
}

4.0 版本 < redis_version < 6.0 版本:引入lazy-free**,**手动开启lazy-free时,有4个选项可以控制,分别对应不同场景下,是否开启异步释放内存机制:

  • lazyfree-lazy-expire:key在过期删除时尝试异步释放内存
  • lazyfree-lazy-eviction:内存达到maxmemory并设置了淘汰策略时尝试异步释放内存
  • lazyfree-lazy-server-del:执行RENAME/MOVE等命令或需要覆盖一个key时,删除旧key尝试异步释放内存
  • replica-lazy-flush:主从全量同步,从库清空数据库时异步释放内存

开启lazy-free后,Redis在释放一个key的内存时,首先会评估代价,如果释放内存的代价很小,那么就直接在主线程中操作了,没必要放到异步线程中执行

redis_version >= 6.0 版本:引入lazyfree-lazy-user-del,只要开启了,del直接可以异步删除key,不会阻塞主线程。具体是为什么呢,现在先卖个关子,在下面进行解析。

5.2.2、SCAN

SCAN命令可以帮助在不阻塞主线程的情况下逐步遍历大量的键,以及避免对数据库的阻塞。以下代码是利用scan来扫描集群中的Key。

public void scanRedis(String cursor,String endCursor) {ReloadableJimClientFactory factory = new ReloadableJimClientFactory();String jimUrl = "jim://xxx/546";factory.setJimUrl(jimUrl);Cluster client = factory.getClient();ScanOptions.ScanOptionsBuilder scanOptions = ScanOptions.scanOptions();scanOptions.count(100);Boolean end = false;int k = 0;while (!end) {KeyScanResult< String > result = client.scan(cursor, scanOptions.build());for (String key :result.getResult()){if (client.ttl(key) == -1){logger.info("永久key为:{}" , key);}}k++;cursor = result.getCursor();if (endCursor.equals(cursor)){break;}}}
5.2.3、UNLINK

Redis 4.0 提供了 lazy delete (unlink命令) ,下面基于源码(redis_version:7.2版本)分析下实现原理

  • del与unlink命令底层都调用了delGenericCommand()方法;
void delCommand(client *c) {delGenericCommand(c,server.lazyfree_lazy_user_del);
}
void unlinkCommand(client *c) {delGenericCommand(c,1);
}
  • lazyfree-lazy-user-del支持yes或者no。默认是no;
  • 如果设置为yes,那么del命令就等价于unlink,也是异步删除,这也同时解释了之前咱们的问题,为什么设置了lazyfree-lazy-user-del后,del命令就为异步删除。
void delGenericCommand(client *c, int lazy) {int numdel = 0, j;// 遍历所有输入键for (j = 1; j < c->argc; j++) {// 先删除过期的键expireIfNeeded(c->db,c->argv[j],0);int deleted  = lazy ? dbAsyncDelete(c->db,c->argv[j]) :dbSyncDelete(c->db,c->argv[j]);// 尝试删除键if (deleted) {// 删除键成功,发送通知signalModifiedKey(c,c->db,c->argv[j]);notifyKeyspaceEvent(NOTIFY_GENERIC,"del",c->argv[j],c->db->id);server.dirty++;// 成功删除才增加 deleted 计数器的值numdel++;}}// 返回被删除键的数量addReplyLongLong(c,numdel);
}

下面分析异步删除dbAsyncDelete()与同步删除dbSyncDelete(),底层同时也是调用dbGenericDelete()方法

int dbSyncDelete(redisDb *db, robj *key) {return dbGenericDelete(db, key, 0, DB_FLAG_KEY_DELETED);
}int dbAsyncDelete(redisDb *db, robj *key) {return dbGenericDelete(db, key, 1, DB_FLAG_KEY_DELETED);
}int dbGenericDelete(redisDb *db, robj *key, int async, int flags) {dictEntry **plink;int table;dictEntry *de = dictTwoPhaseUnlinkFind(db->dict,key->ptr,&plink,&table);if (de) {robj *val = dictGetVal(de);/* RM_StringDMA may call dbUnshareStringValue which may free val, so we need to incr to retain val */incrRefCount(val);/* Tells the module that the key has been unlinked from the database. */moduleNotifyKeyUnlink(key,val,db->id,flags);/* We want to try to unblock any module clients or clients using a blocking XREADGROUP */signalDeletedKeyAsReady(db,key,val->type);// 在调用用freeObjAsync之前,我们应该先调用decrRefCount。否则,引用计数可能大于1,导致freeObjAsync无法正常工作。decrRefCount(val);// 如果是异步删除,则会调用 freeObjAsync 异步释放 value 占用的内存。同时,将 key 对应的 value 设置为 NULL。if (async) {/* Because of dbUnshareStringValue, the val in de may change. */freeObjAsync(key, dictGetVal(de), db->id);dictSetVal(db->dict, de, NULL);}// 如果是集群模式,还会更新对应 slot 的相关信息if (server.cluster_enabled) slotToKeyDelEntry(de, db);/* Deleting an entry from the expires dict will not free the sds of the key, because it is shared with the main dictionary. */if (dictSize(db->expires) > 0) dictDelete(db->expires,key->ptr);// 释放内存dictTwoPhaseUnlinkFree(db->dict,de,plink,table);return 1;} else {return 0;}
}

如果为异步删除,调用freeObjAsync()方法,根据以下代码分析:

#define LAZYFREE_THRESHOLD 64/* Free an object, if the object is huge enough, free it in async way. */
void freeObjAsync(robj *key, robj *obj, int dbid) {size_t free_effort = lazyfreeGetFreeEffort(key,obj,dbid);if (free_effort > LAZYFREE_THRESHOLD && obj->refcount == 1) {atomicIncr(lazyfree_objects,1);bioCreateLazyFreeJob(lazyfreeFreeObject,1,obj);} else {decrRefCount(obj);}
}size_t lazyfreeGetFreeEffort(robj *key, robj *obj, int dbid) {if (obj->type == OBJ_LIST && obj->encoding == OBJ_ENCODING_QUICKLIST) {quicklist *ql = obj->ptr;return ql->len;} else if (obj->type == OBJ_SET && obj->encoding == OBJ_ENCODING_HT) {dict *ht = obj->ptr;return dictSize(ht);} else if (obj->type == OBJ_ZSET && obj->encoding == OBJ_ENCODING_SKIPLIST){zset *zs = obj->ptr;return zs->zsl->length;} else if (obj->type == OBJ_HASH && obj->encoding == OBJ_ENCODING_HT) {dict *ht = obj->ptr;return dictSize(ht);} else if (obj->type == OBJ_STREAM) {...return effort;} else if (obj->type == OBJ_MODULE) {size_t effort = moduleGetFreeEffort(key, obj, dbid);/* If the module's free_effort returns 0, we will use asynchronous free* memory by default. */return effort == 0 ? ULONG_MAX : effort;} else {return 1; /* Everything else is a single allocation. */}
}

分析后咱们可以得出如下结论:

  • 当Hash/Set底层采用哈希表存储(非ziplist/int编码存储)时,并且元素数量超过64个
  • 当ZSet底层采用跳表存储(非ziplist编码存储)时,并且元素数量超过64个
  • 当List链表节点数量超过64个(注意,不是元素数量,而是链表节点的数量,List的实现是在每个节点包含了若干个元素的数据,这些元素采用ziplist存储)
  • refcount == 1 就是在没有引用这个Key时

只有以上这些情况,在删除key释放内存时,才会真正放到异步线程中执行,其他情况一律还是在主线程操作。也就是说String(不管内存占用多大)、List(少量元素)、Set(int编码存储)、Hash/ZSet(ziplist编码存储)这些情况下的key在释放内存时,依旧在主线程中操作。

5.3、分而治之

采用经典算法“分治法”,将大而化小。针对String和集合类型的Key,可以采用如下方式:

  • String类型的大Key:可以尝试将对象分拆成几个Key-Value, 使用MGET或者多个GET组成的pipeline获取值,分拆单次操作的压力,对于集群来说可以将操作压力平摊到多个分片上,降低对单个分片的影响。
  • 集合类型的大Key,并且需要整存整取要在设计上严格禁止这种场景的出现,如无法拆分,有效的方法是将该大Key从JIMDB去除,单独放到其他存储介质上。
  • 集合类型的大Key,每次只需操作部分元素:将集合类型中的元素分拆。以Hash类型为例,可以在客户端定义一个分拆Key的数量N,每次对HGET和HSET操作的field计算哈希值并取模N,确定该field落在哪个Key上。

如果线上服务强依赖Redis,需要考虑到如何做到“无感”,并保证数据一致性。咱们基本上可以采用三步走策略,如下图所示。分别是进行双写,双读校验,最后读新Key。在此基础上可以设置开关,做到上线后的平稳迁移。

六、总结

综上所述,针对文章开头咱们购物车大Key问题,相信你已经有了答案。咱们可以限制门店数,限制门店中的商品数。如果不作限制,咱们也能进行拆分,将大Key分散存储。例如。将Redis中Key类型改为List,key为用户与门店唯一键,Value为用户在此门店下的商品。

存储结构拆分成两种:
第一种:userPin:storeId的集合
第二种:userPin_storeId1:{门店下加车的所有商品基本信息};userPin_storeId2:{门店下加车的所有商品基本信息}     

以上介绍了大key的产生、识别、处理,以及如何使用合理策略和技术来应对。在使用Redis过程中,防范大于治理,在治理过程中也要做到业务无感。

七、参考

https://github.com/redis/redis.git

http://redisbook.com/

https://github.com/huangz1990/redis-3.0-annotated.git

https://blog.csdn.net/ldw201510803006/article/details/124790121

https://blog.csdn.net/kuangd_1992/article/details/130451679

http://sd.jd.com/article/4930?shareId=119428&isHideShareButton=1

https://www.liujiajia.me/2023/3/28/redis-bigkeys

https://www.51cto.com/article/701990.html

https://help.aliyun.com/document_detail/353223.html

https://juejin.cn/post/7167015025154981895

https://www.jianshu.com/p/9e150d72ffc9

https://zhuanlan.zhihu.com/p/449648332

作者:京东零售 高凯

来源:京东云开发者社区 转载请注明来源

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/177849.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

SpringMVC Day 08 : 文件上传下载

前言 文件上传和下载是 Web 开发中的重要环节&#xff0c;但它们往往不那么容易实现。幸运的是&#xff0c;Spring MVC 提供了一套简单而又强大的解决方案&#xff0c;让我们可以专注于业务逻辑&#xff0c;而不必过多关注底层的文件处理细节。 在本篇博客中&#xff0c;我们…

UE5——网络——RPC

RPC&#xff08;这个是官方文档的资料&#xff09; 要将一个函数声明为 RPC&#xff0c;您只需将 Server、Client 或 NetMulticast 关键字添加到 UFUNCTION 声明。 例如&#xff0c;若要将某个函数声明为一个要在服务器上调用、但需要在客户端上执行的 RPC&#xff0c;您可以…

在Maven中发布项目到Nexus私有服务器

一、测试环境 Sonatype Nexus 3.61.0-02 Maven 3.9.2 二、环境配置 2.1找到maven的配置文件 2.2添加私有仓库账户密码 <servers><server><id>nexus</id><username>admin</username><password>admin</password></server&…

【Linux】Linux+Nginx部署项目(负载均衡动静分离)

&#x1f973;&#x1f973;Welcome Huihuis Code World ! !&#x1f973;&#x1f973; 接下来看看由辉辉所写的关于Linux的相关操作吧 目录 &#x1f973;&#x1f973;Welcome Huihuis Code World ! !&#x1f973;&#x1f973; 一.Nginx负载均衡 1.什么是负载均衡 2.实…

网站如何改成HTTPS访问

在今天的互联网环境中&#xff0c;将网站更改成HTTPS访问已经成为了一种标准做法。HTTPS不仅有助于提高网站的安全性&#xff0c;还可以提高搜索引擎排名&#xff0c;并增强用户信任。因此&#xff0c;转换为HTTPS是一个重要的举措&#xff0c;无论您拥有个人博客、电子商务网站…

年度评选开启,边缘力量驱动科技未来!

随着人工智能技术的快速发展&#xff0c;边缘计算作为一种新兴技术&#xff0c;正逐渐成为实现智能制造、智慧城市、自动驾驶等领域的关键技术之一。边缘计算能够在靠近数据源的地方进行数据处理和分析&#xff0c;从而提高数据的实时性和可靠性&#xff0c;同时降低网络带宽和…

【Linux】jdk Tomcat MySql的安装及Linux后端接口部署

一&#xff0c;jdk安装 1.1 上传安装包到服务器 打开MobaXterm通过Linux地址连接到Linux并登入Linux&#xff0c;再将主机中的配置文件复制到MobaXterm 使用命令查看&#xff1a;ll 1.2 解压对应的安装包 解压jdk 解压命令&#xff1a;tar -xvf jdk 加键盘中Tab键即可…

【LVS实战】02 搭建一个LVS-NAT模式实验

一、网络结构 用虚拟机搭建如下的几台机器&#xff0c;并配置如下的ip 关于虚拟机网卡和网络的配置&#xff0c;可以参考 iptables章节&#xff0c;05节&#xff1a;网络转发实验 主机A模拟外网的机器 B为负载均衡的机器 C和D为 RealServer 二、C和D主机的网关设置 C和D机…

ROS学习笔记(4):ROS架构和通讯机制

前提 前4篇文章以及帮助大家快速入门ROS了&#xff0c;而从第5篇开始我们会更加注重知识积累。同时我强烈建议配合B站大学的视频一起服用。 1.ROS架构三层次&#xff1a; 1.基于Linux系统的OS层&#xff1b; 2.实现ROS核心通信机制以及众多机器人开发库的中间层&#xff1b…

Redis的四种部署方案

这篇文章介绍Reids最为常见的四种部署模式&#xff0c;其实Reids和数据库的集群模式差不多&#xff0c;可以分为 Redis单机模式部署、Redis主从模式部署、Redis哨兵模式部署、Cluster集群模式部署&#xff0c;其他的部署方式基本都是围绕以下几种方式在进行调整到适应的生产环境…

40 深度学习(四):卷积神经网络|深度可分离卷积|colab和kaggle的基础使用

文章目录 卷积神经网络为什么要卷积卷积的具体流程池化tensorflow代码 深度可分离卷积原理介绍计算量对比代码参数计算例子 colab 和 kagglecolabkaggle如何在colab上使用kaggle的数据 卷积神经网络 卷积神经网络的基本结构 1&#xff1a; (卷积层(可选)池化层) * N全连接层 *…

网络安全应急响应工具(系统痕迹采集)-FireKylin

文章目录 网络安全应急响应工具(系统痕迹采集)-FireKylin1.FireKylin介绍【v1.4.0】 2021-12-20【v1.0.1】 2021-08-09 2.客户端界面Agent支持的操作系统FireKylinAgent界面使用方式比较传统方式与FireKylin比较无法可达目标的场景应用对比 3.使用教程设置语言Agent配置&#x…

离散傅里叶变换中的能量守恒公式(帕斯瓦尔定理)及其程序举例验证

离散傅里叶变换中的能量守恒公式&#xff08;帕斯瓦尔定理&#xff09;及其程序举例验证 一、 离散傅里叶变换中的能量守恒公式 离散傅里叶变换中的能量守恒公式&#xff1a; ∑ n 0 N − 1 ∣ x [ n ] ∣ 2 1 N ∑ k 0 N − 1 ∣ X [ k ] ∣ 2 (1) \sum\limits_{n 0}^{N…

【C++】医学影像信息管理系统源码

狭义的医学影像信息系统是指基于医学影像存储和通信系统的管理系统&#xff0c;从技术上解决了影像处理技术。临床信息系统是指支持医院医务人员临床活动&#xff0c;收集和处理患者临床医疗信息的信息管理系统。放射科信息系统是指放射科挂号、分诊、影像诊断报告、信息查询、…

pycharm 断点调试python Flask

以flask框架为例&#xff0c;其启动命令为 python app.py runserver 后面需要拼接runserver 点击开始断点 参考&#xff1a;https://www.cnblogs.com/bigtreei/p/14742015.html

vue-cli5.0.x优雅降级,配置项目兼容旧版浏览器

兼容低版本谷歌浏览器 vue-cli5.0.x脚手架下的&#xff0c;如何降低项目版本以适用于底版本的浏览器。 直接使用默认配置打包部署出来的项目再40&#xff0c;60、70版本的谷歌浏览器跑不起来&#xff0c;蓝屏或者浏览器白屏一般这种情况都需要通过Babel去做转换&#xff0c;我…

什么?前端又出新轮子了?ofa.js

不需要打包的 MVVM JavaScript 框架 无需繁琐学习&#xff0c;无需 npm、nodejs、webpack&#xff0c;即刻上手 <script src"https://cdn.jsdelivr.net/gh/kirakiray/ofa.js/dist/ofa.min.js"></script>官方文档 取代 jQuery 在许多小型项目中&#x…

【机器学习合集】模型设计之注意力机制动态网络 ->(个人学习记录笔记)

文章目录 注意力机制1. 注意力机制及其应用1.1 注意力机制的定义1.2 注意力机制的典型应用 2. 注意力模型设计2.1 空间注意力机制2.2 空间注意力模型2.3 通道注意力机制2.4 空间与通道注意力机制2.5 自注意力机制2.5 级联attention 动态网络1. 动态网络的定义2. 基于丢弃策略的…

Debian或Ubuntu静态交叉编译arm和aarch64

Debian或Ubuntu静态交叉编译arm和aarch64 介绍术语ARM架构前置条件从源代码编译一个简单的C程序configure和make交叉编译关于静态链接和依赖关系使用 musl libc 实现与 configure 和 make 进行交叉编译 ARM 正在获得越来越多的关注&#xff0c;并且越来越受欢迎。直接在这些基于…

深度学习_3 数据操作之线代,微分

线代基础 标量 只有一个元素的张量。可以通过 x torch.tensor(3.0) 方式创建。 向量 由多个标量组成的列表&#xff08;一维张量&#xff09;。比如 x torch.arange(4) 就是创建了一个1*4的向量。可以通过下标获取特定元素&#xff08;x[3]&#xff09;&#xff0c;可以通…