华为设备 MIB 获取方法:http://support.huawei.com/onlinetoolweb/infoM/index.do?domain=1&lang=zh&topicType=mib
导出 excel 后取出所需的 OID 列即可
这是我基于华为 S5700-V200R013C00 整理的 logstash 用的 OID 信息:https://download.csdn.net/download/iaiot/11263207
将上一步整理的 yaml 文件放到 logstash yamlmibdir 目录1
2
3
4
5
6
7
8
9input{
snmptrap {
type => "snmptrap"
id => "my_snmptrap"
community => "***"
port => "162"
yamlmibdir => "/usr/share/logstash/vendor/bundle/jruby/1.9/gems/snmp-1.2.0/data/ruby/snmp/mibs"
}
}
使用 docker 部署 logstash 映射端口时需注意设备发的是 udp 消息
compose.yml:1
2
3
4
5
6
7
8
9……
ports:
- "9600:9600"
- "7777:7777"
- "2224:2224"
- "514:514/udp"
- "2223:2223"
- "162:162/udp"
……
分组捕获又分为两种,一种是自定义命名的分组,还有一种是未命名的分组(或者称为自动编号分组)
命名分组的格式为:(?<name>X) 其中X表示一个正则表达式 如:(?<ip>[\d]{1,3}.[\d]{1,3}.[\d]{1,3}.[\d]{1,3})
JDK 中的正则是 NFA 实现的
java DFA 开源实现:https://github.com/zhztheplayer/DFA-Regex
DFA 速度快但是部分正则功能不支持
https://www.jb51.net/article/31168.htm
1.减少回溯
2.对固定正则在循环前提前编译 Pattern.compile
3.使用位置匹配符号 ^ 和 $
4.使用 DFA 正则引擎
5.参考文章:
https://www.jianshu.com/p/bbf3c382fd30
https://blog.csdn.net/csdncjh/article/details/51191616
http://blog.chacuo.net/329.html
http://blog.chacuo.net/255.html
https://my.oschina.net/u/3147332/blog/807081
https://segmentfault.com/a/1190000000735725
RegexBuddy4.9
http://blog.chacuo.net/238.html
物联网设备节点组网存在2种组网方式,无线组网和有线组网。无线组网我们常见到的有Zigbee,LoRa,NB-IOT等,其中Lora/NB-IOT属于LPWAN技术,LPWAN技术有覆盖广、连接多、速率低、成本低、功耗少等特点。
NB-IoT有个明显的优势是数据采集后可直接上传到云端,不需要通过网关,简化了现场部署。通常要部署一个网关需要考虑位置,周围信号影响,考虑因素较多。
现在把这个三个无线组网方案做一个较全面对比,以供在做方案选择时候做参考:
NB-IOT | LoRa | Zigbee | |
---|---|---|---|
组网方式 | 基于现有蜂窝组网 | 基于LoRa网关 | 基于Zigbee网关 |
网络部署方式 | 节点 | 节点 + 网关(网关部署位置要求较高,需要考虑因素多) | 节点 + 网关 |
传输距离 | 远距离(可达十几公里,一般情况下10KM以上) | 远距离(可达十几公里,城市1~2公里,郊区可达20km) | 短距离(10米~百米级别) |
单网接入节点容量 | 约20万 | 约6万,实际受网关信道数量,节点发包频率,数据包大小等有关。一般有500~5000个不等 | 理论6万多个,一般情况200~500个 |
电池续航 | 理论约10年/AA电池 | 理论约10年/AA电池 | 理论约2年/AA电池 |
成本 | 模块5-10$,未来目标降到1$ | 模块约5$ | 模块约1~2$ |
频段 | License频段,运营商频段 | unlicense频段,Sub-GHZ(433、868、915 MHz等) | unlicense频段2.4G |
传输速度 | 理论160kbp ~ 250Kbps,实际一般小于100kbps,受限低速通信接口UART | 0.3~50kbps | 理论250kps,实际一般小于100kbps,受限低速通信接口UART |
网络时延 | 6s -10s | TBD | 不到1S |
适合领域 | 户外场景,LPWAN;大面积传感器应用 | 户外场景,LPWAN;大面积传感器应用;可搭私有网网络,蜂窝网络覆盖不到地方 | 常见于户内场景,户外也有,LPLAN;小范围传感器应用;可搭建私有网网络。 |
联网方式 | 终端设备本身就具备联网能力,直接接入网络 | 终端设备本身不具备入网能力,需要在本地组网后,需要统一通过网关再接入到网络 | 终端设备本身不具备入网能力,需要在本地组网后,需要统一通过网关再接入到网络 |
1 | curl -X GET "http://127.0.0.1:9201/_cat/indices?v&h=index,docs.count,store.size&s=store.size:desc&bytes=b" |
v:verbose 有无标题
h:headers 返回的字段
s:排序
bytes:store.size 单位,数字格式输出,不带 mb,gb 等单位,方便在代码中计算
help:查看字段意思
官方文档:https://www.elastic.co/guide/en/elasticsearch/reference/current/cat-indices.html
或者 _stats,这个要比 _cat 慢很多1
curl -X GET "http://127.0.0.1:9201/_all/_stats"
简单的说: Java把内存划分成两种:一种是栈内存,一种是堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。
在堆中分配的内存,由Java虚拟机的自动垃圾回收器来管理。
栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同,Java自动管理栈和堆,程序员不能直接地设置栈或堆。
栈的优势是,存取速度比堆要快,仅次于直接位于CPU中的寄存器。但缺点是,存在栈中的数据大小与生存期必须是确定的,缺乏灵活性。另外,栈数据可以共享,详见第3点。堆的优势是可以动态地分配内存大小,生存期也不必事先告诉编译器,Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是,由于要在运行时动态分配内存,存取速度较慢。
Java中的数据类型有两种。 一种是基本类型(primitive types), 共有8种,即int, short, long, byte, float, double, boolean, char(注意,并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的,称为自动变量。值得注意的是,自动变量存的是字面值,不是类的实例,即不是类的引用,这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用,指向3这个字面值。这些字面值的数据,由于大小可知,生存期可知(这些字面值固定定义在某个程序块里面,程序块退出后,字段值就消失了),出于追求速度的原因,就存在于栈中。
另外,栈有一个很重要的特殊性,就是存在栈中的数据可以共享。假设我们同时定义
int a = 3; int b = 3;
编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用,然后查找有没有字面值为3的地址,没找到,就开辟一个存放3这个字面值的地址,然后将a指向3的地址。接着处理int b = 3;在创建完b的引用变量后,由于在栈中已经有3这个字面值,便将b直接指向3的地址。这样,就出现了a与b同时均指向3的情况。
特别注意的是,这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象,如果一个对象引用变量修改了这个对象的内部状态,那么另一个对象引用变量也即刻反映出这个变化。相反,通过字面值的引用来修改其值,不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例,我们定义完a与 b的值后,再令a=4;那么,b不会等于4,还是等于3。在编译器内部,遇到a=4;时,它就会重新搜索栈中是否有4的字面值,如果没有,重新开辟地址存放4的值;如果已经有了,则直接将a指向这个地址。因此a值的改变不会影响到b的值。
另一种是包装类数据,如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中,Java用new()语句来显式地告诉编译器,在运行时才根据需要动态创建,因此比较灵活,但缺点是要占用更多的时间。
是不是违反了上述原则?其实没有。
(1)先定义一个名为str的对String类的对象引用变量:String str;
(2)在栈中查找有没有存放值为”abc”的地址,如果没有,则开辟一个存放字面值为”abc”的地址,接着创建一个新的String类的对象o,并将o 的字符串值指向这个地址,而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为”abc”的地址,则查找对象o,并返回o的地址。
(3)将str指向对象o的地址。 值得注意的是,一般String类中字符串值都是直接存值的。但像String str = “abc”;这种场合下,其字符串值却是保存了一个指向存在栈中数据的引用! 为了更好地说明这个问题,我们可以通过以下的几个代码进行验证。
String str1 = “abc”; String str2 = “abc”;
System.out.println(str1==str2); //true
注意,我们这里并不用str1.equals(str2);的方式,因为这将比较两个字符串的值是否相等。==号,根据JDK的说明,只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是,str1与str2是否都指向了同一个对象。 结果说明,JVM创建了两个引用str1和str2,但只创建了一个对象,而且两个引用都指向了这个对象。 我们再来更进一步,将以上代码改成:
String str1 = “abc”;
String str2 = “abc”;
str1 = “bcd”;
System.out.println(str1 + “,” + str2); //bcd, abc
System.out.println(str1==str2); //false
这就是说,赋值的变化导致了类对象引用的变化,str1指向了另外一个新对象!而str2仍旧指向原来的对象。上例中,当我们将str1的值改为”bcd”时,JVM发现在栈中没有存
放该值的地址,便开辟了这个地址,并创建了一个新的对象,其字符串的值指向这个地址。
事实上,String类被设计成为不可改变(immutable)的类。如果你要改变其值,可以,但JVM在运行时根据新值悄悄创建了一个新对象,然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的,但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中,会带有一定的不良影响。 再修改原来代码:
String str1 = “abc”;
String str2 = “abc”;
str1 = “bcd”;
String str3 = str1;
System.out.println(str3); //bcd
String str4 = “bcd”;
System.out.println(str1 == str4); //true
str3 这个对象的引用直接指向str1所指向的对象(注意,str3并没有创建新对象)。当str1改完其值后,再创建一个String的引用str4,并指向因str1修改值而创建的新的对象。可以发现,这回str4也没有创建新的对象,从而再次实现栈中数据的共享。 我们再接着看以下的代码。
String str1 = new String(“abc”);
String str2 = “abc”;
System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
String str1 = “abc”;
String str2 = new String(“abc”);
System.out.println(str1==str2); //false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。 以上两段代码说明,只要是用new()来新建对象的,都会在堆中创建,而且其字符串是单独存值的,即使与栈中的数据相同,也不会与栈中的数据共享。
包装类都不能更改其内部的值。
(1)我们在使用诸如String str = “abc”;的格式定义类时,总是想当然地认为,我们创建了String类的对象str。担心陷阱!对象可能并没有被创建!唯一可以肯定的是,指向 String类的引用被创建了。至于这个引用到底是否指向了一个新的对象,必须根据上下文来考虑,除非你通过new()方法来显要地创建一个新的对象。因此,更为准确的说法是,我们创建了一个指向String类的对象的引用变量str,这个对象引用变量指向了某个值为”abc”的String类。清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。
(2)使用String str = “abc”;的方式,可以在一定程度上提高程序的运行速度,因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String(“abc”);的代码,则一概在堆中创建新对象,而不管其字符串值是否相等,是否有必要创建新对象,从而加重了程序的负担。这个思想应该是享元模式的思想,但JDK的内部在这里实现是否应用了这个模式,不得而知。
(3)当比较包装类里面的数值是否相等时,用equals()方法;当测试两个包装类的引用是否指向同一个对象时,用==。
(4)由于String类的immutable性质,当String变量需要经常变换其值时,应该考虑使用StringBuffer类,以提高程序效率。
内存分配策略
按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.
静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在
编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.
栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。
静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.
上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:
从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的,栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:
在编程中,例如C/C++中,所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候,修改栈指针就可以把栈中的内容销毁.这样的模式速度最快,当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个”大小多少”是在编译时确定的,不是在运行时.
堆是应用程序在运行的时候请求操作系统分配给自己内存,由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间,因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间,也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中,要求创建一个对象时,只需用 new命令编制相关的代码即可。执行这些代码时,会在堆里自动进行数据的保存.当然,为达到这种灵活性,必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).
JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说,它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。 我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的. 从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域,该区域具有先进后出的特性。 每一个Java应用都唯一对应一个JVM实例,每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程 共享.跟C/C++不同,Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的,但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存,在堆中分配的内存实际建立这个对象,而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。
Java为什么慢?JVM的存在当然是一个原因,但有人说,在Java中,除了简单类型(int,char等)的数据结构,其它都是在堆中分配内存(所以说Java的一切都是对象),这也
是程序慢的原因之一。
我的想法是(应该说代表TIJ的观点),如果没有Garbage Collector(GC),上面的说法就是成立的.堆不象栈是连续的空间,没有办法指望堆本身的内存分配能够象堆栈一样拥有传送带般的速度,因为,谁会 为你整理庞大的堆空间,让你几乎没有延迟的从堆中获取新的空间呢?
这个时候,GC站出来解决问题.我们都知道GC用来清除内存垃圾,为堆腾出空间供程序使用,但GC同时也担负了另外一个重要的任务,就是要让Java中堆的内存分配和其他语言中堆栈的内存分配一样快,因为速度的问题几乎是众口一词的对Java的诟病.要达到这样的目的,就必须使堆的分配也能够做到象传送带一样,不用自己操心去找空闲空间.这样,GC除了负责清除Garbage外,还要负责整理堆中的对象,把它们转移到一个远离Garbage的纯净空间中无间隔的排列起来,就象堆栈中一样紧凑,这样Heap Pointer就可以方便的指向传送带的起始位置,或者说一个未使用的空间,为下一个需要分配内存的对象”指引方向”.因此可以这样说,垃圾收集影响了对象的创建速度,听起来很怪,对不对?
那GC怎样在堆中找到所有存活的对象呢?前面说了,在建立一个对象时,在堆中分配实际建立这个对象的内存,而在堆栈中分配一个指向这个堆对象的指针(引 用),那么只要在堆栈(也有可能在静态存储区)找到这个引用,就可以跟踪到所有存活的对象.找到之后,GC将它们从一个堆的块中移到另外一个堆的块中,并 将它们一个挨一个的排列起来,就象我们上面说的那样,模拟出了一个栈的结构,但又不是先进后出的分配,而是可以任意分配的,在速度可以保证的情况下, Isn’t it great?
但是,列宁同志说了,人的优点往往也是人的缺点,人的缺点往往也是人的优点(再晕~~).GC()的运行要占用一个线程,这本身就是一个降低程序运行性能 的缺陷,更何况这个线程还要在堆中把内存翻来覆去的折腾.不仅如此,如上面所说,堆中存活的对象被搬移了位置,那么所有对这些对象的引用都要重新赋值.这 些开销都会导致性能的降低.
基础数据类型直接在栈空间分配,方法的形式参数,直接在栈空间分配,当方法调用完成后从栈空间回收。引用数据类型,需要用new来创建,既在栈空间 分配一个地址空间,又在堆空间分配对象的类变量 。方法的引用参数,在栈空间分配一个地址空间,并指向堆空间的对象区,当方法调用完成后从栈空间回收。局部变量new出来时,在栈空间和堆空间中分配空 间,当局部变量生命周期结束后,栈空间立刻被回收,堆空间区域等待GC回收。方法调用时传入的literal参数,先在栈空间分配,在方法调用完成后从栈 空间分配。字
符串常量在DATA区域分配,this在堆空间分配。数组既在栈空间分配数组名称,又在堆空间分配数组实际的大小!
JVM是基于堆栈的虚拟机。JVM为每个新创建的线程都分配一个堆栈。也就是说,对于一个Java程序来说,它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。 我们知道,某个线程正在执行的方法称为此线程的当前方法。我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在 线程的Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据。这个帧在这里 和编译原理中的活动纪录的概念是差不多的。 从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域,该区域具有先进后出的特性。
每一个Java应用都唯一对应一个JVM实例,每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有 的线程共享。跟C/C++不同,Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的,但是这个对象的引用却是在堆栈中分 配,也就是说在建立一个对象时从两个地方都分配内存,在堆中分配的内存实际建立这个对象,而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。
原文地址:https://www.cnblogs.com/guoxiaoyan/p/8664150.html
①栈(操作系统):由操作系统自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。
②堆(操作系统): 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收,分配方式倒是类似于链表。
①栈使用的是一级缓存, 他们通常都是被调用时处于存储空间中,调用完毕立即释放。
②堆则是存放在二级缓存中,生命周期由虚拟机的垃圾回收算法来决定(并不是一旦成为孤儿对象就能被回收)。所以调用这些对象的速度要相对来得低一些。
①堆(数据结构):堆可以被看成是一棵树,如:堆排序。
②栈(数据结构):一种先进后出的数据结构。
before_install:install 之前执行
install:安装依赖
before_script:script 之前执行
script:运行脚本
aftersuccess:script 成功后执行
afterfailure:script 失败后执行
before_deploy:deploy 之前执行
deploy:部署
after_deploy:deploy 之后执行
after_script:script 之后执行
1 | language: node_js |
其中配置中有不便于公开的参数值,比如用户名密码、各种 token 等都可以放到 Travis 的环境变量中,然后在 .travis.yml 中通过 ${env_key} 引用
这个博客就是使用 Travis CI 构建的,见:https://github.com/haojiliang/haojiliang.github.io/tree/dev
]]>定期清理 elasticsearch 中 n 天以前的数据
通过shell脚本实现:
选择功能模块(
1.清理日志
2.添加清理任务
3.删除清理任务
)
清理日志:手动清理指定天数之前的日志数据
添加清理任务:包含内置的清理周期(小时、天、周、月)
删除清理任务:删除添加的日志清理任务
1 | !/bin/bash |
$ openssl genrsa -aes256 -out ca-key.pem 4096
$ openssl req -new -x509 -days 365 -key ca-key.pem -sha256 -out ca.pem
$ openssl genrsa -out server-key.pem 4096
$ openssl req -subj “/CN=docker-server” -sha256 -new -key server-key.pem -out server.csr
$ echo subjectAltName = DNS:docker-server,IP:127.0.0.1 >> extfile.cnf
$ echo extendedKeyUsage = serverAuth >> extfile.cnf
$ openssl x509 -req -days 365 -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out server-cert.pem -extfile extfile.cnf
$ openssl genrsa -out key.pem 4096
$ openssl req -subj ‘/CN=client’ -new -key key.pem -out client.csr
$ echo extendedKeyUsage = clientAuth > extfile-client.cnf
$ openssl x509 -req -days 365 -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem -extfile extfile-client.cnf
$ rm -v client.csr server.csr extfile.cnf extfile-client.cnf
参考:https://docs.docker.com/engine/security/https/
其中 docker-server 为访问 docker api 用的域名
配置host:192.168.153.7 docker-server
这个docker-server就相当于ssl证书的域名,这个证书是这个域名用的,换用其他域名连接会报证书验证失败
配置 /etc/docker/daemon.json,没有则新建1
2
3
4
5
6
7
8
9
10{
"tlsverify": true,
"tlscert": "/root/cert/server-cert.pem",
"tlskey": "/root/cert/server-key.pem",
"tlscacert": "/root/cert/ca.pem",
"hosts": [
"tcp://0.0.0.0:2376",
"unix:///var/run/docker.sock"
]
}
docker-java:https://github.com/docker-java/docker-java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public static DockerClient getDockerClient() {
DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
.withDockerHost("tcp://docker-server:2376")
.withDockerTlsVerify(true)
.withDockerCertPath("/root/youCertPath")
.build();
DockerCmdExecFactory dockerCmdExecFactory = new JerseyDockerCmdExecFactory()
.withReadTimeout(20000)
.withConnectTimeout(1000)
.withMaxTotalConnections(100)
.withMaxPerRouteConnections(10);
DockerClient dockerClient = DockerClientBuilder.getInstance(config)
.withDockerCmdExecFactory(dockerCmdExecFactory)
.build();
return dockerClient;
}
唯一需要注意的是:StringBuffer是线程安全的,但是StringBuilder是线程不安全的。可参看Java标准类库的源代码,StringBuffer类中方法定义前面都会有synchronize关键字。为此,StringBuffer的性能要远低于StringBuilder。
所以:
在频繁进行字符串的运算(如拼接、替换、删除等),且运行在多线程环境下,使用StringBuffer。
在频繁进行字符串的运算(如拼接、替换、删除等),且运行在单线程环境下,使用StringBuilder。
1 | public static final String CHANNEL_KEY = "channel:1"; |
1 | /** |
1 | location /ws/createwebsocket { |
spring-websocket 不支持 resin,如果用 resin 部署服务,需基于 com.caucho.websocket.WebSocketListener 自己实现,或者依赖一个其他的 spring 支持的 websocket 包,如:1
2
3
4
5<dependency>
<groupId>io.undertow</groupId>
<artifactId>undertow-websockets-jsr</artifactId>
<version>2.0.17.Final</version>
</dependency>
spring-websocket 支持的 RequestUpgradeStrategy:
倒排索引是实现“单词-文档矩阵”的一种具体存储形式,通过倒排索引,可以根据单词快速获取包含这个单词的文档列表。倒排索引主要由两个部分组成:“单词词典”和“倒排文件”。
原文:http://www.cnblogs.com/zlslch/p/6440114.html
单词ID:记录每个单词的单词编号;
单词:对应的单词;
文档频率:代表文档集合中有多少个文档包含某个单词
倒排列表:包含单词ID及其他必要信息
DocId:单词出现的文档id
TF:单词在某个文档中出现的次数
POS:单词在文档中出现的位置
以单词“加盟”为例,其单词编号为6,文档频率为3,代表整个文档集合中有三个文档包含这个单词,对应的倒排列表为{(2;1;<4>),(3;1;<7>),(5;1;<5>)},含义是在文档2,3,5出现过这个单词,在每个文档的出现过1次,单词“加盟”在第一个文档的POS是4,即文档的第四个单词是“加盟”,其他的类似。
这个倒排索引已经是一个非常完备的索引系统,实际搜索系统的索引结构基本如此。5>7>4>
https://github.com/medcl/elasticsearch-analysis-ik
http://www.cnblogs.com/zlslch/p/6440373.html
keyword:不进行分词,直接索引、支持模糊、精确查询、支持聚合
text:会分词,然后进行索引、支持模糊、精确查询、不支持聚合
默认的动态模板,可以同时支持两种类型
参考:https://elasticsearch.cn/question/2099
https://www.jianshu.com/p/0d13dd7d813a
https://blog.csdn.net/u011652364/article/details/78581737
1 | curl -XPUT -u elastic 'http://127.0.0.1:9200/_xpack/security/user/elastic/_password' -d '{ |
9、修改kibana配置文件elastic的密码改为changeme并启动
10、使用kibana修改elastic密码
11、kibana停机重新修改配置文件为新密码
12、重启kibana 并测试es使用新密码连接
http://www.lanrenkaifa.com/post/61
http://blog.51yip.com/server/1906.html
kibana x-pack安装完了后,license有效期只有1个月,并且每年需要,要重新续一次。
通过curl,重新续一下license,注意:文件名前面有一个@符号
1 | curl -XPUT -u elastic:xxxxxxx 'http://localhost:9200/_xpack/license?acknowledge=true&pretty' -H "Content-Type: application/json" -d @hao-jiliang-a07994e8-9e65-404c-a8d1-4d84cbe62fc8-v5.json |
查看license状态:
1 | curl -XGET -u admin:123456 'localhost:9200/_xpack/license' |
logstash 接收 rsyslog 消息:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29input {
syslog {
port => "514"
add_field => [ "type", "syslog"]
}
}
filter {
if "syslog" in [type]
{
grok {}
mutate {
add_field => [ "a", "%{[host]}"]
add_field => [ "b", "0"]
}
}
geoip {}
}
output {
kafka {
bootstrap_servers => "192.168.0.100:9092"
topic_id => "tttttest"
#compression_type => "snappy"
codec => "json"
}
# stdout { codec => rubydebug } # 调试输出
}
1 | <beans xmlns="http://www.springframework.org/schema/beans" |
1 | package com.iaiot.xxx.task; |
每天凌晨1点执行:0 0 1 ?
每周一凌晨2点30执行:0 30 2 ? MON
每月1号凌晨4点执行:0 0 4 1 ?
配置文件 server.xml 中 appBase=”webapps” 改为 appBase=””
配置文件 resin.xml 中 <web-app-deploy path=”webapps” 改为 <web-app-deploy path=””
1 | BEGIN |
SELECT kuo.user_id FROM kk_user_org kuo WHERE kuo.org_id IN(getChildOrgIdsByUserId(100))
]]>设置 root 密码:sudo passwd root
开启 root 远程登录:/etc/ssh/sshd_config 中 PermitRootLogin 改为 yes,StrictModes 改为 yes
然后:sudo service ssh restart
Ubuntu16 配置静态 ip:https://www.jianshu.com/p/d69a95aa1ed7
ubuntu18 配置静态 ip:https://blog.csdn.net/u010039418/article/details/80934346
查询软件:apt-cache madison kubeadm
安装指定版本:apt-get install -y kubeadm=1.11.6-00
彻底卸载软件:
删除软件及其配置文件 apt-get –purge remove kubeadm
删除没用的依赖包 apt-get autoremove kubeadm
此时dpkg的列表中有“rc”状态的软件包,可以执行如下命令做最后清理 dpkg -l |grep ^rc|awk ‘{print $2}’ |sudo xargs dpkg -P
关闭防火墙
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
iptables -F