Mingyu's Blog 我荒废的今日，正是昨天殒身之人祈求的明日 2018-05-21T05:01:47.000Z https://www.mingyugu.com/ Mingyu Gu Hexo Hexo博客自动部署 https://www.mingyugu.com/hexo-auto-deploy.html 2018-05-21T05:01:47.000Z 2018-05-21T05:01:47.000Z ]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><!-- rebuild by neat --> 后端架构师技术图谱 https://www.mingyugu.com/architect-awesome.html 2018-05-10T02:34:12.000Z 2018-05-10T02:34:12.000Z

文章摘录自：《后端架构师技术图谱》

数据结构

队列

集合

链表、数组

字典、关联数组

栈

树

二叉树

每个节点最多有两个叶子节点。

完全二叉树

  • 《完全二叉树》
    • 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。

平衡二叉树

左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉查找树（BST）

二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree）。

红黑树

B-，B+，B*树

MySQL是基于B+树聚集索引组织表

LSM 树

LSM（Log-Structured Merge-Trees）和 B+ 树相比，是牺牲了部分读的性能来换取写的性能(通过批量写入)，实现读写之间的。
Hbase、LevelDB、Tair（Long DB）、nessDB 采用 LSM 树的结构。LSM可以快速建立索引。

  • 《LSM树 VS B+树》

    • B+ 树读性能好，但由于需要有序结构，当key比较分散时，磁盘寻道频繁，造成写性能。
    • LSM 是将一个大树拆分成N棵小树，先写到内存（无寻道问题，性能高），在内存中构建一颗有序小树（有序树），随着小树越来越大，内存的小树会flush到磁盘上。当读时，由于不知道数据在哪棵小树上，因此必须遍历（二分查找）所有的小树，但在每颗小树内部数据是有序的。

  • 《LSM树（Log-Structured Merge Tree）存储引擎》

    • 极端的说，基于LSM树实现的HBase的写性能比MySQL高了一个数量级，读性能低了一个数量级。
    • 优化方式：Bloom filter 替代二分查找；compact 小数位大树，提高查询性能。
    • Hbase 中，内存中达到一定阈值后，整体flush到磁盘上、形成一个文件（B+数），HDFS不支持update操作，所以Hbase做整体flush而不是merge update。flush到磁盘上的小树，定期会合并成一个大树。

BitSet

经常用于大规模数据的排重检查。

常用算法

排序、查找算法

选择排序

冒泡排序

插入排序

快速排序

归并排序

希尔排序

TODO

堆排序

计数排序

桶排序

基数排序

按照个位、十位、百位、…依次来排。

二分查找

Java 中的排序工具

布隆过滤器

常用于大数据的排重，比如email，url 等。
核心原理：将每条数据通过计算产生一个指纹（一个字节或多个字节，但一定比原始数据要少很多），其中每一位都是通过随机计算获得，在将指纹映射到一个大的按位存储的空间中。注意：会有一定的错误率。
优点：空间和时间效率都很高。
缺点：随着存入的元素数量增加，误算率随之增加。

字符串比较

KMP 算法

KMP：Knuth-Morris-Pratt算法（简称KMP）
核心原理是利用一个“部分匹配表”，跳过已经匹配过的元素。

深度优先、广度优先

贪心算法

回溯算法

剪枝算法

动态规划

朴素贝叶斯

推荐算法

最小生成树算法

最短路径算法

并发

  1. 基础知识

    1.1 并发编程的优缺点

    知识点：（1）为什么要用到并发？（优点）；（2）并发编程的缺点；（3）易混淆的概念

    1.2 线程的状态和基本操作

    知识点：（1）如何新建线程；（2）线程状态的转换；（3）线程的基本操作；（4）守护线程Daemon；

  2. 并发理论（JMM）

    java内存模型以及happens-before规则

    知识点：（1）JMM内存结构；（2）重排序；（3）happens-before规则

  3. 并发关键字

    3.1 让你彻底理解Synchronized

    知识点：（1）如何使用synchronized；（2）monitor机制；（3）synchronized的happens-before关系；（4）synchronized的内存语义；（5）锁优化；（6）锁升级策略

    3.2 让你彻底理解volatile

    知识点：（1）实现原理；（2）happens-before的关系推导；（3）内存语义；（4）内存语义的实现

    3.3 你以为你真的了解final吗？

    知识点：（1）如何使用；（2）final的重排序规则；（3）final实现原理；（4）final引用不能从构造函数中“溢出”（this逃逸）

    3.4 三大性质总结：原子性，有序性，可见性

    知识点：（1）原子性：synchronized；（2）可见性：synchronized，volatile；（3）有序性：synchronized，volatile

  4. Lock体系

    4.1 初识Lock与AbstractQueuedSynchronizer(AQS)

    知识点：（1）Lock和synchronized的比较；（2）AQS设计意图；（3）如何使用AQS实现自定义同步组件；（4）可重写的方法；（5）AQS提供的模板方法；

    4.2 深入理解AbstractQueuedSynchronizer(AQS)

    知识点：（1）AQS同步队列的数据结构；（2）独占式锁；（3）共享式锁；

    4.3 再一次理解ReentrantLock

    知识点：（1）重入锁的实现原理；（2）公平锁的实现原理；（3）非公平锁的实现原理；（4）公平锁和非公平锁的比较

    4.4 深入理解读写锁ReentrantReadWriteLock

    知识点：（1）如何表示读写状态；（2）WriteLock的获取和释放；（3）ReadLock的获取和释放；（4）锁降级策略；（5）生成Condition等待队列；（6）应用场景

    4.5 详解Condition的await和signal等待/通知机制

    知识点：（1）与Object的wait/notify机制相比具有的特性；（2）与Object的wait/notify相对应的方法；（3）底层数据结构；（4）await实现原理；（5）signal/signalAll实现原理；（6）await和signal/signalAll的结合使用；

    4.6 LockSupport工具

    知识点：（1）主要功能；（2）与synchronized阻塞唤醒相比具有的特色；

  5. 并发容器

    5.1 并发容器之ConcurrentHashMap(JDK 1.8版本)

    知识点：（1）关键属性；（2）重要内部类；（3）涉及到的CAS操作；（4）构造方法；（5）put执行流程；（6）get执行流程；（7）扩容机制；（8）用于统计size的方法的执行流程；（9）1.8版本的ConcurrentHashMap与之前版本的比较

    5.2 并发容器之CopyOnWriteArrayList

    知识点：（1）实现原理；（2）COW和ReentrantReadWriteLock的区别；（3）应用场景；（4）为什么具有弱一致性；（5）COW的缺点；

    5.3 并发容器之ConcurrentLinkedQueue

    知识点：（1）实现原理；（2）数据结构；（3）核心方法；（4）HOPS延迟更新的设计意图

    5.4 并发容器之ThreadLocal

    知识点：（1）实现原理；（2）set方法原理；（3）get方法原理；（4）remove方法原理；（5）ThreadLocalMap

    一篇文章，从源码深入详解ThreadLocal内存泄漏问题

    知识点：（1）ThreadLocal内存泄漏原理；（2）ThreadLocal的最佳实践；（3）应用场景

    5.5 并发容器之BlockingQueue

    知识点：（1）BlockingQueue的基本操作；（2）常用的BlockingQueue；

    并发容器之ArrayBlockingQueue和LinkedBlockingQueue实现原理详解

  6. 线程池（Executor体系）

    6.1 线程池实现原理

    知识点：（1）为什么要用到线程池？（2）执行流程；（3）构造器各个参数的意义；（4）如何关闭线程池；（5）如何配置线程池；

    6.2 线程池之ScheduledThreadPoolExecutor

    知识点：（1）类结构；（2）常用方法；（3）ScheduledFutureTask；（3）DelayedWorkQueue;

    6.3 FutureTask基本操作总结

    知识点：（1）FutureTask的几种状态；（2）get方法；（3）cancel方法；（4）应用场景；（5）实现 Runnable接口

  7. 原子操作类

    7.1 Java中atomic包中的原子操作类总结

    知识点：（1）实现原理；（2）原子更新基本类型；（3）原子更新数组类型；（4）原子更新引用类型；（5）原子更新字段类型

  8. 并发工具

    8.1 大白话说java并发工具类-CountDownLatch，CyclicBarrier

    知识点：（1）倒计时器CountDownLatch；（2）循环栅栏CyclicBarrier；（3）CountDownLatch与CyclicBarrier的比较

    8.2 大白话说java并发工具类-Semaphore，Exchanger

    知识点：（1）资源访问控制Semaphore；（2）数据交换Exchanger

  9. 并发实践

    9.1 一篇文章，让你彻底弄懂生产者–消费者问题

JAVA并发知识图谱

可移动到新窗口，放大查看效果更好或者查看原图

知识图谱原图链接，如果有用，可克隆给自己使用

JAVA并发知识图谱.png
JAVA并发知识图谱.png

多线程

线程安全

一致性、事务

事务 ACID 特性

事务的隔离级别

  • 未提交读：一个事务可以读取另一个未提交的数据，容易出现脏读的情况。
  • 读提交：一个事务等另外一个事务提交之后才可以读取数据，但会出现不可重复读的情况（多次读取的数据不一致），读取过程中出现UPDATE操作，会多。（大多数数据库默认级别是RC，比如SQL Server，Oracle），读取的时候不可以修改。
  • 可重复读： 同一个事务里确保每次读取的时候，获得的是同样的数据，但不保障原始数据被其他事务更新（幻读），Mysql InnoDB 就是这个级别。

  • 序列化：所有事物串行处理（牺牲了效率）

  • 《理解事务的4种隔离级别》

  • 数据库事务的四大特性及事务隔离级别

  • 《MySQL的InnoDB的幻读问题 》

    • 幻读的例子非常清楚。
    • 通过 SELECT … FOR UPDATE 解决。

  • 《一篇文章带你读懂MySQL和InnoDB》

    • 图解脏读、不可重复读、幻读问题。

MVCC

锁

Java中的锁和同步类

公平锁 & 非公平锁

公平锁的作用就是严格按照线程启动的顺序来执行的，不允许其他线程插队执行的；而非公平锁是允许插队的。

悲观锁

悲观锁如果使用不当（锁的条数过多），会引起服务大面积等待。推荐优先使用乐观锁+重试。

乐观锁 & CAS

ABA 问题

由于高并发，在CAS下，更新后可能此A非彼A。通过版本号可以解决，类似于上文Mysql 中提到的的乐观锁。

CopyOnWrite容器

可以对CopyOnWrite容器进行并发的读，而不需要加锁。CopyOnWrite并发容器用于读多写少的并发场景。比如白名单，黑名单，商品类目的访问和更新场景，不适合需要数据强一致性的场景。

RingBuffer

可重入锁 & 不可重入锁

  • 《可重入锁和不可重入锁》

    • 通过简单代码举例说明可重入锁和不可重入锁。
    • 可重入锁指同一个线程可以再次获得之前已经获得的锁。
    • 可重入锁可以用户避免死锁。
    • Java中的可重入锁：synchronized 和 java.util.concurrent.locks.ReentrantLock

  • 《ReenTrantLock可重入锁（和synchronized的区别）总结》

    • synchronized 使用方便，编译器来加锁，是非公平锁。
    • ReenTrantLock 使用灵活，锁的公平性可以定制。
    • 相同加锁场景下，推荐使用 synchronized。

互斥锁 & 共享锁

互斥锁：同时只能有一个线程获得锁。比如，ReentrantLock 是互斥锁，ReadWriteLock 中的写锁是互斥锁。
共享锁：可以有多个线程同时或的锁。比如，Semaphore、CountDownLatch 是共享锁，ReadWriteLock 中的读锁是共享锁。

死锁

操作系统

计算机原理

CPU

多级缓存

典型的 CPU 有三级缓存，距离核心越近，速度越快，空间越小。L1 一般 32k，L2 一般 256k，L3 一般12M。内存速度需要200个 CPU 周期，CPU 缓存需要1个CPU周期。

进程

TODO

线程

协程

  • 《终结python协程—-从yield到actor模型的实现》
    • 线程的调度是由操作系统负责，协程调度是程序自行负责
    • 与线程相比，协程减少了无谓的操作系统切换.
    • 实际上当遇到IO操作时做切换才更有意义，（因为IO操作不用占用CPU），如果没遇到IO操作，按照时间片切换.

Linux

设计模式

设计模式的六大原则

  • 《设计模式的六大原则》
    • 开闭原则：对扩展开放,对修改关闭，多使用抽象类和接口。
    • 里氏代换原则：基类可以被子类替换，使用抽象类继承,不使用具体类继承。
    • 依赖倒转原则：要依赖于抽象,不要依赖于具体，针对接口编程,不针对实现编程。
    • 接口隔离原则：使用多个隔离的接口,比使用单个接口好，建立最小的接口。
    • 迪米特法则：一个软件实体应当尽可能少地与其他实体发生相互作用，通过中间类建立联系。
    • 合成复用原则：尽量使用合成/聚合,而不是使用继承。

23种常见设计模式

应用场景

  • 《细数JDK里的设计模式》

    • 结构型模式：

      • 适配器：用来把一个接口转化成另一个接口，如 java.util.Arrays#asList()。
      • 桥接模式：这个模式将抽象和抽象操作的实现进行了解耦，这样使得抽象和实现可以独立地变化，如JDBC；
      • 组合模式：使得客户端看来单个对象和对象的组合是同等的。换句话说，某个类型的方法同时也接受自身类型作为参数，如 Map.putAll，List.addAll、Set.addAll。
      • 装饰者模式：动态的给一个对象附加额外的功能，这也是子类的一种替代方式，如 java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap。
      • 享元模式：使用缓存来加速大量小对象的访问时间，如 valueOf(int)。
      • 代理模式：代理模式是用一个简单的对象来代替一个复杂的或者创建耗时的对象，如 java.lang.reflect.Proxy

    • 创建模式:

      • 抽象工厂模式：抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不用指定具体对象的类型，如 java.util.Calendar#getInstance()。
      • 建造模式(Builder)：定义了一个新的类来构建另一个类的实例，以简化复杂对象的创建，如：java.lang.StringBuilder#append()。
      • 工厂方法：就是 一个返* 回具体对象的方法，而不是多个，如 java.lang.Object#toString()、java.lang.Class#newInstance()。
      • 原型模式：使得类的实例能够生成自身的拷贝、如：java.lang.Object#clone()。
      • 单例模式：全局只有一个实例，如 java.lang.Runtime#getRuntime()。
    • 行为模式：
      • 责任链模式：通过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦。如 javax.servlet.Filter#doFilter()。
      • 命令模式：将操作封装到对象内，以便存储，传递和返回，如：java.lang.Runnable。
      • 解释器模式：定义了一个语言的语法，然后解析相应语法的语句，如，java.text.Format，java.text.Normalizer。
      • 迭代器模式：提供一个一致的方法来顺序访问集合中的对象，如 java.util.Iterator。
      • 中介者模式：通过使用一个中间对象来进行消息分发以及减少类之间的直接依赖，java.lang.reflect.Method#invoke()。
      • 空对象模式：如 java.util.Collections#emptyList()。
      • 观察者模式：它使得一个对象可以灵活的将消息发送给感兴趣的对象，如 java.util.EventListener。
      • 模板方法模式：让子类可以重写方法的一部分，而不是整个重写，如 java.util.Collections#sort()。

  • 《Spring-涉及到的设计模式汇总》

  • 《Mybatis使用的设计模式》

单例模式

责任链模式

TODO

MVC

IOC

  • 《理解 IOC》
  • 《IOC 的理解与解释》
    • 正向控制：传统通过new的方式。反向控制，通过容器注入对象。
    • 作用：用于模块解耦。
    • DI：Dependency Injection，即依赖注入，只关心资源使用，不关心资源来源。

AOP

UML

微服务思想

康威定律

  • 《微服务架构的理论基础 - 康威定律》

    • 定律一：组织沟通方式会通过系统设计表达出来，就是说架构的布局和组织结构会有相似。
    • 定律二：时间再多一件事情也不可能做的完美，但总有时间做完一件事情。一口气吃不成胖子，先搞定能搞定的。
    • 定律三：线型系统和线型组织架构间有潜在的异质同态特性。种瓜得瓜，做独立自治的子系统减少沟通成本。
    • 定律四：大的系统组织总是比小系统更倾向于分解。合久必分，分而治之。

  • 《微服务架构核⼼20讲》

运维 & 统计 & 技术支持

常规监控

命令行监控工具

APM

APM — Application Performance Management

统计分析

持续集成(CI/CD)

Jenkins

环境分离

开发、测试、生成环境分离。

自动化运维

Ansible

puppet

chef

测试

TDD 理论

  • 《深度解读 - TDD（测试驱动开发）》
    • 基于测试用例编码功能代码，XP（Extreme Programming）的核心实践.
    • 好处：一次关注一个点，降低思维负担；迎接需求变化或改善代码的设计；提前澄清需求；快速反馈；

单元测试

压力测试

全链路压测

A/B 、灰度、蓝绿测试

虚拟化

KVM

Xen

OpenVZ

容器技术

Docker

云技术

OpenStack

DevOps

文档管理

中间件

Web Server

Nginx

OpenResty

Apache Httpd

Tomcat

架构原理

调优方案

Jetty

  • 《Jetty 的工作原理以及与 Tomcat 的比较》
  • 《jetty和tomcat优势比较》
    • 架构比较:Jetty的架构比Tomcat的更为简单。
    • 性能比较：Jetty和Tomcat性能方面差异不大，Jetty默认采用NIO结束在处理I/O请求上更占优势，Tomcat默认采用BIO处理I/O请求，Tomcat适合处理少数非常繁忙的链接，处理静态资源时性能较差。
    • 其他方面：Jetty的应用更加快速，修改简单，对新的Servlet规范的支持较好;Tomcat 对JEE和Servlet 支持更加全面。

缓存

本地缓存

客户端缓存

服务端缓存

Web缓存

Memcached

Redis

  • 《Redis 教程》
  • 《redis底层原理》
    • 使用 ziplist 存储链表，ziplist是一种压缩链表，它的好处是更能节省内存空间，因为它所存储的内容都是在连续的内存区域当中的。
    • 使用 skiplist(跳跃表)来存储有序集合对象、查找上先从高Level查起、时间复杂度和红黑树相当，实现容易，无锁、并发性好。

  • 《Redis持久化方式》

    • RDB方式：定期备份快照，常用于灾难恢复。优点：通过fork出的进程进行备份，不影响主进程、RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。缺点：会丢数据。
    • AOF方式：保存操作日志方式。优点：恢复时数据丢失少，缺点：文件大，回复慢。
    • 也可以两者结合使用。

  • 《分布式缓存–序列3–原子操作与CAS乐观锁》

架构

回收策略

Tair

  • 官方网站
  • 《Tair和Redis的对比》
  • 特点：可以配置备份节点数目，通过异步同步到备份节点
  • 一致性Hash算法。
  • 架构：和Hadoop 的设计思想类似，有Configserver，DataServer，Configserver 通过心跳来检测，Configserver也有主备关系。

几种存储引擎:

  • MDB，完全内存性，可以用来存储Session等数据。
  • Rdb（类似于Redis），轻量化，去除了aof之类的操作，支持Restfull操作
  • LDB（LevelDB存储引擎），持久化存储，LDB 作为rdb的持久化，google实现，比较高效，理论基础是LSM(Log-Structured-Merge Tree)算法，现在内存中修改数据，达到一定量时（和内存汇总的旧数据一同写入磁盘）再写入磁盘，存储更加高效，县比喻Hash算法。
  • Tair采用共享内存来存储数据，如果服务挂掉（非服务器），重启服务之后，数据亦然还在。

消息队列

消息总线

消息总线相当于在消息队列之上做了一层封装，统一入口，统一管控、简化接入成本。

消息的顺序

RabbitMQ

支持事务，推拉模式都是支持、适合需要可靠性消息传输的场景。

RocketMQ

Java实现，推拉模式都是支持，吞吐量逊于Kafka。可以保证消息顺序。

ActiveMQ

纯Java实现，兼容JMS，可以内嵌于Java应用中。

Kafka

高吞吐量、采用拉模式。适合高IO场景，比如日志同步。

Redis 消息推送

生产者、消费者模式完全是客户端行为，list 和 拉模式实现，阻塞等待采用 blpop 指令。

ZeroMQ

TODO

定时调度

单机定时调度

分布式定时调度

RPC

Dubbo

SPI
TODO

Thrift

gRPC

服务端可以认证加密，在外网环境下，可以保证数据安全。

数据库中间件

Sharding Jdbc

日志系统

日志搜集

配置中心

servlet 3.0 异步特性可用于配置中心的客户端

API 网关

主要职责：请求转发、安全认证、协议转换、容灾。

网络

协议

OSI 七层协议

TCP/IP

HTTP

HTTP2.0

HTTPS

网络模型

  • 《web优化必须了解的原理之I/o的五种模型和web的三种工作模式》

    • 五种I/O模型：阻塞I/O，非阻塞I/O，I/O复用、事件(信号)驱动I/O、异步I/O，前四种I/O属于同步操作，I/O的第一阶段不同、第二阶段相同，最后的一种则属于异步操作。
    • 三种 Web Server 工作方式：Prefork(多进程)、Worker方式(线程方式)、Event方式。

  • 《select、poll、epoll之间的区别总结》

    • select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的。
    • select 有打开文件描述符数量限制，默认1024（2048 for x64），100万并发，就要用1000个进程、切换开销大；poll采用链表结构，没有数量限制。
    • select，poll “醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，通过回调机制节省大量CPU时间；select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，而epoll只要一次拷贝。
    • poll会随着并发增加，性能逐渐下降，epoll采用红黑树结构，性能稳定，不会随着连接数增加而降低。

  • 《select，poll，epoll比较 》

    • 在连接数少并且连接都十分活跃的情况下，select和poll的性能可能比epoll好，毕竟epoll的通知机制需要很多函数回调。

  • 《深入理解Java NIO》

    • NIO 是一种同步非阻塞的 IO 模型。同步是指线程不断轮询 IO 事件是否就绪，非阻塞是指线程在等待 IO 的时候，可以同时做其他任务

  • 《BIO与NIO、AIO的区别》

  • 《两种高效的服务器设计模型：Reactor和Proactor模型》

Epoll

Java NIO

kqueue

连接和短连接

框架

零拷贝（Zero-copy）

序列化(二进制协议)

Hessian

Protobuf

数据库

基础理论

数据库设计的三大范式

  • 《数据库的三大范式以及五大约束》
    • 第一范式：数据表中的每一列（每个字段）必须是不可拆分的最小单元，也就是确保每一列的原子性；
    • 第二范式（2NF）：满足1NF后，要求表中的所有列，都必须依赖于主键，而不能有任何一列与主键没有关系，也就是说一个表只描述一件事情；
    • 第三范式：必须先满足第二范式（2NF），要求：表中的每一列只与主键直接相关而不是间接相关，（表中的每一列只能依赖于主键）；

MySQL

原理

InnoDB

优化

索引

聚集索引, 非聚集索引

MyISAM 是非聚集，InnoDB 是聚集

复合索引

自适应哈希索引(AHI)

explain

NoSQL

MongoDB

  • MongoDB 教程
  • 《Mongodb相对于关系型数据库的优缺点》
    • 优点：弱一致性（最终一致），更能保证用户的访问速度；内置GridFS，支持大容量的存储；Schema-less 数据库，不用预先定义结构；内置Sharding；相比于其他NoSQL，第三方支持丰富；性能优越；
    • 缺点：mongodb不支持事务操作；mongodb占用空间过大；MongoDB没有如MySQL那样成熟的维护工具，这对于开发和IT运营都是个值得注意的地方；

Hbase

搜索引擎

搜索引擎原理

Lucene

Elasticsearch

Solr

sphinx

性能

性能优化方法论

容量评估

CDN 网络

连接池

性能调优

大数据

流式计算

Storm

Kafka Stream

应用场景

例如：

  • 广告相关实时统计；
  • 推荐系统用户画像标签实时更新；
  • 线上服务健康状况实时监测；
  • 实时榜单；
  • 实时数据统计。

Hadoop

HDFS

MapReduce

Yarn

Spark

安全

web 安全

XSS

CSRF

SQL 注入

Hash Dos

脚本注入

漏洞扫描工具

验证码

DDoS 防范

用户隐私信息保护

  1. 用户密码非明文保存，加动态slat。
  2. 身份证号，手机号如果要显示，用 “*” 替代部分字符。
  3. 联系方式在的显示与否由用户自己控制。
  4. TODO

序列化漏洞

加密解密

对称加密

  • 《常见对称加密算法》
    • DES、3DES、Blowfish、AES
    • DES 采用 56位秘钥，Blowfish 采用1到448位变长秘钥，AES 128，192和256位长度的秘钥。
    • DES 秘钥太短（只有56位）算法目前已经被 AES 取代，并且 AES 有硬件加速，性能很好。

哈希算法

非对称加密

服务器安全

数据安全

数据备份

TODO

网络隔离

内外网分离

TODO

登录跳板机

在内外环境中通过跳板机登录到线上主机。

授权、认证

RBAC

OAuth2.0

双因素认证（2FA）

2FA - Two-factor authentication，用于加强登录验证

常用做法是 登录密码 + 手机验证码（或者令牌Key，类似于与网银的 USB key）

单点登录(SSO)

常用开源框架

开源协议

日志框架

Log4j、Log4j2

Logback

ORM

MyBatis：

网络框架

TODO

Web 框架

Spring 家族

Spring

Spring Boot

Spring Cloud

工具框架

分布式设计

扩展性设计

稳定性 & 高可用

  • 《系统设计：关于高可用系统的一些技术方案》

    • 可扩展：水平扩展、垂直扩展。 通过冗余部署，避免单点故障。
    • 隔离：避免单一业务占用全部资源。避免业务之间的相互影响 2. 机房隔离避免单点故障。
    • 解耦：降低维护成本，降低耦合风险。减少依赖，减少相互间的影响。
    • 限流：滑动窗口计数法、漏桶算法、令牌桶算法等算法。遇到突发流量时，保证系统稳定。
    • 降级：紧急情况下释放非核心功能的资源。牺牲非核心业务，保证核心业务的高可用。
    • 熔断：异常情况超出阈值进入熔断状态，快速失败。减少不稳定的外部依赖对核心服务的影响。
    • 自动化测试：通过完善的测试，减少发布引起的故障。
    • 灰度发布：灰度发布是速度与安全性作为妥协，能够有效减少发布故障。

  • 《关于高可用的系统》

    • 设计原则：数据不丢(持久化)；服务高可用(服务副本)；绝对的100%高可用很难，目标是做到尽可能多的9，如99.999%（全年累计只有5分钟）。

硬件负载均衡

软件负载均衡

限流

  • 《谈谈高并发系统的限流》
    • 计数器：通过滑动窗口计数器，控制单位时间内的请求次数，简单粗暴。
    • 漏桶算法：固定容量的漏桶，漏桶满了就丢弃请求，比较常用。
    • 令牌桶算法：固定容量的令牌桶，按照一定速率添加令牌，处理请求前需要拿到令牌，拿不到令牌则丢弃请求，或进入丢队列，可以通过控制添加令牌的速率，来控制整体速度。Guava 中的 RateLimiter 是令牌桶的实现。
    • Nginx 限流：通过 limit_req 等模块限制并发连接数。

应用层容灾

  • 《防雪崩利器：熔断器 Hystrix 的原理与使用》

    • 雪崩效应原因：硬件故障、硬件故障、程序Bug、重试加大流量、用户大量请求。
    • 雪崩的对策：限流、改进缓存模式(缓存预加载、同步调用改异步)、自动扩容、降级。
    • Hystrix设计原则：
      • 资源隔离：Hystrix通过将每个依赖服务分配独立的线程池进行资源隔离, 从而避免服务雪崩。
      • 熔断开关：服务的健康状况 = 请求失败数 / 请求总数，通过阈值设定和滑动窗口控制开关。
      • 命令模式：通过继承 HystrixCommand 来包装服务调用逻辑。

  • 《缓存穿透，缓存击穿，缓存雪崩解决方案分析》

  • 《缓存击穿、失效以及热点key问题》
    • 主要策略：失效瞬间：单机使用锁；使用分布式锁；不过期；
    • 热点数据：热点数据单独存储；使用本地缓存；分成多个子key；

跨机房容灾

  • 《“异地多活”多机房部署经验谈》

    • 通过自研中间件进行数据同步。

  • 《异地多活（异地双活）实践经验》

    • 注意延迟问题，多次跨机房调用会将延时放大数倍。
    • 建房间专线很大概率会出现问题，做好运维和程序层面的容错。
    • 不能依赖于程序端数据双写，要有自动同步方案。
    • 数据永不在高延迟和较差网络质量下，考虑同步质量问题。
    • 核心业务和次要业务分而治之，甚至只考虑核心业务。
    • 异地多活监控部署、测试也要跟上。
    • 业务允许的情况下考虑用户分区，尤其是游戏、邮箱业务。
    • 控制跨机房消息体大小，越小越好。
    • 考虑使用docker容器虚拟化技术，提高动态调度能力。

  • 容灾技术及建设经验介绍

容灾演练流程

平滑启动

数据库扩展

读写分离模式

分片模式

  • 《分库分表需要考虑的问题及方案》

    • 中间件： 轻量级：sharding-jdbc、TSharding；重量级：Atlas、MyCAT、Vitess等。
    • 问题：事务、Join、迁移、扩容、ID、分页等。
    • 事务补偿：对数据进行对帐检查;基于日志进行比对;定期同标准数据来源进行同步等。
    • 分库策略：数值范围；取模；日期等。
    • 分库数量：通常 MySQL 单库 5千万条、Oracle 单库一亿条需要分库。

  • 《MySql分表和表分区详解》

    • 分区：是MySQL内部机制，对客户端透明，数据存储在不同文件中，表面上看是同一个表。
    • 分表：物理上创建不同的表、客户端需要管理分表路由。

服务治理

服务注册与发现

服务路由控制

  • 《分布式服务框架学习笔记4 服务路由》
    • 原则：透明化路由
    • 负载均衡策略：随机、轮询、服务调用延迟、一致性哈希、粘滞连接
    • 本地路由有限策略：injvm(优先调用jvm内部的服务)，innative(优先使用相同物理机的服务),原则上找距离最近的服务。
    • 配置方式：统一注册表；本地配置；动态下发。

分布式一致

CAP 与 BASE 理论

  • 《从分布式一致性谈到CAP理论、BASE理论》
    • 一致性分类：强一致(立即一致)；弱一致(可在单位时间内实现一致，比如秒级)；最终一致(弱一致的一种，一定时间内最终一致)
    • CAP：一致性、可用性、分区容错性(网络故障引起)
    • BASE：Basically Available（基本可用）、Soft state（软状态）和Eventually consistent（最终一致性）
    • BASE理论的核心思想是：即使无法做到强一致性，但每个应用都可以根据自身业务特点，采用适当的方式来使系统达到最终一致性。

分布式锁

  • 《分布式锁的几种实现方式》
    • 基于数据库的分布式锁：优点：操作简单、容易理解。缺点：存在单点问题、数据库性能够开销较大、不可重入；
    • 基于缓存的分布式锁：优点：非阻塞、性能好。缺点：操作不好容易造成锁无法释放的情况。
    • Zookeeper 分布式锁：通过有序临时节点实现锁机制，自己对应的节点需要最小，则被认为是获得了锁。优点：集群可以透明解决单点问题，避免锁不被释放问题，同时锁可以重入。缺点：性能不如缓存方式，吞吐量会随着zk集群规模变大而下降。

  • 《基于Zookeeper的分布式锁》

    • 清楚的原理描述 + Java 代码示例。

  • 《jedisLock—redis分布式锁实现》

    • 基于 setnx(set if ont exists)，有则返回false，否则返回true。并支持过期时间。

  • 《Memcached 和 Redis 分布式锁方案》

    • 利用 memcached 的 add（有别于set）操作，当key存在时，返回false。

分布式一致性算法

PAXOS

Zab

Raft

Gossip

两阶段提交、多阶段提交

幂等

  • 《分布式系统—幂等性设计》
    • 幂等特性的作用：该资源具备幂等性，请求方无需担心重复调用会产生错误。
    • 常见保证幂等的手段：MVCC（类似于乐观锁）、去重表(唯一索引)、悲观锁、一次性token、序列号方式。

分布式一致方案

分布式 Leader 节点选举

TCC(Try/Confirm/Cancel) 柔性事务

  • 《传统事务与柔性事务》
    • 基于BASE理论：基本可用、柔性状态、最终一致。
    • 解决方案：记录日志+补偿（正向补充或者回滚）、消息重试(要求程序要幂等)；“无锁设计”、采用乐观锁机制。

分布式文件系统

唯一ID 生成

全局唯一ID

  • 《高并发分布式系统中生成全局唯一Id汇总》

    • Twitter 方案（Snowflake 算法）：41位时间戳+10位机器标识（比如IP，服务器名称等）+12位序列号(本地计数器)
    • Flicker 方案：MySQL自增ID + “REPLACE INTO XXX:SELECT LAST_INSERT_ID();”
    • UUID：缺点，无序，字符串过长，占用空间，影响检索性能。
    • MongoDB 方案：利用 ObjectId。缺点：不能自增。

  • 《TDDL 在分布式下的SEQUENCE原理》

    • 在数据库中创建 sequence 表，用于记录，当前已被占用的id最大值。
    • 每台客户端主机取一个id区间（比如 1000~2000）缓存在本地，并更新 sequence 表中的id最大值记录。
    • 客户端主机之间取不同的id区间，用完再取，使用乐观锁机制控制并发。

一致性Hash算法

设计思想 & 开发模式

DDD(Domain-driven Design - 领域驱动设计)

  • 《浅谈我对DDD领域驱动设计的理解》

    • 概念：DDD 主要对传统软件开发流程(分析-设计-编码)中各阶段的割裂问题而提出，避免由于一开始分析不明或在软件开发过程中的信息流转不一致而造成软件无法交付（和需求方设想不一致）的问题。DDD 强调一切以领域（Domain）为中心，强调领域专家（Domain Expert）的作用，强调先定义好领域模型之后在进行开发，并且领域模型可以指导开发（所谓的驱动）。
    • 过程：理解领域、拆分领域、细化领域，模型的准确性取决于模型的理解深度。
    • 设计：DDD 中提出了建模工具，比如聚合、实体、值对象、工厂、仓储、领域服务、领域事件来帮助领域建模。

  • 《领域驱动设计的基础知识总结》

    • 领域（Doamin）本质上就是问题域，比如一个电商系统，一个论坛系统等。
    • 界限上下文（Bounded Context）：阐述子域之间的关系，可以简单理解成一个子系统或组件模块。
    • 领域模型（Domain Model）：DDD的核心是建立（用通用描述语言、工具—领域通用语言）正确的领域模型；反应业务需求的本质，包括实体和过程；其贯穿软件分析、设计、开发 的整个过程；常用表达领域模型的方式：图、代码或文字；
    • 领域通用语言：领域专家、开发设计人员都能立即的语言或工具。
    • 经典分层架构：用户界面/展示层、应用层、领域层、基础设施层，是四层架构模式。
    • 使用的模式：
      • 关联尽量少，尽量单项，尽量降低整体复杂度。
      • 实体（Entity）：领域中的唯一标示，一个实体的属性尽量少，少则清晰。
      • 值对象（Value Object）：没有唯一标识，且属性值不可变，小二简单的对象，比如Date。
      • 领域服务（Domain Service）： 协调多个领域对象，只有方法没有状态(不存数据)；可以分为应用层服务，领域层服务、基础层服务。
      • 聚合及聚合根（Aggregate，Aggregate Root）：聚合定义了一组具有内聚关系的相关对象的集合；聚合根是对聚合引用的唯一元素；当修改一个聚合时，必须在事务级别；大部分领域模型中，有70%的聚合通常只有一个实体，30%只有2~3个实体；如果一个聚合只有一个实体，那么这个实体就是聚合根；如果有多个实体，那么我们可以思考聚合内哪个对象有独立存在的意义并且可以和外部直接进行交互；
      • 工厂（Factory）：类似于设计模式中的工厂模式。
      • 仓储（Repository）：持久化到DB，管理对象，且只对聚合设计仓储。

  • 《领域驱动设计(DDD)实现之路》

    • 聚合：比如一辆汽车（Car）包含了引擎（Engine）、车轮（Wheel）和油箱（Tank）等组件，缺一不可。

  • 《领域驱动设计系列（2）浅析VO、DTO、DO、PO的概念、区别和用处》

命令查询职责分离(CQRS)

CQRS — Command Query Responsibility Seperation

贫血，充血模型

  • 《贫血，充血模型的解释以及一些经验》
    • 失血模型：老子和儿子分别定义，相互不知道，二者实体定义中完全没有业务逻辑，通过外部Service进行关联。
    • 贫血模型：老子知道儿子，儿子也知道老子；部分业务逻辑放到实体中；优点：各层单项依赖，结构清楚，易于维护；缺点：不符合OO思想，相比于充血模式，Service层较为厚重；
    • 充血模型：和贫血模型类似，区别在于如何划分业务逻辑。优点：Service层比较薄，只充当Facade的角色，不和DAO打交道、复合OO思想；缺点：非单项依赖，DO和DAO之间双向依赖、和Service层的逻辑划分容易造成混乱。
    • 肿胀模式：是一种极端情况，取消Service层、全部业务逻辑放在DO中；优点：符合OO思想、简化了分层；缺点：暴露信息过多、很多非DO逻辑也会强行并入DO。这种模式应该避免。
    • 作者主张使用贫血模式。

Actor 模式

TODO

响应式编程

Reactor

TODO

RxJava

TODO

Vert.x

TODO

DODAF2.0

Serverless

TODO

Service Mesh

TODO

项目管理

架构评审

重构

代码规范

TODO

代码 Review

制度还是制度!
另外，每个公司需要根据自己的需求和目标制定自己的 check list

RUP

看板管理

SCRUM

SCRUM - 争球

  • 3个角色:Product Owner(PO) 产品负责人;Scrum Master（SM），推动Scrum执行;Team 开发团队。
  • 3个工件：Product Backlog 产品TODOLIST，含优先级;Sprint Backlog 功能开发 TODO LIST；燃尽图；
  • 五个价值观：专注、勇气、公开、承诺、尊重。

敏捷开发

TODO

极限编程（XP）

XP - eXtreme Programming

  • 《主流敏捷开发方法：极限编程XP》

    • 是一种指导开发人员的方法论。

    • 4大价值：

      • 沟通：鼓励口头沟通，提高效率。
      • 简单：够用就好。
      • 反馈：及时反馈、通知相关人。
      • 勇气：提倡拥抱变化，敢于重构。

    • 5个原则：快速反馈、简单性假设、逐步修改、提倡更改（小步快跑）、优质工作（保证质量的前提下保证小步快跑）。

    • 5个工作：阶段性冲刺；冲刺计划会议；每日站立会议；冲刺后review；回顾会议。

结对编程

边写码，边review。能够增强代码质量、减少bug。

FMEA管理模式

TODO

通用业务术语

TODO

技术趋势

TODO

政策、法规

TODO

法律

严格遵守刑法253法条

我国刑法第253条之一规定：

  • 国家机关或者金融、电信、交通、教育、医疗等单位的工作人员，违反国家规定，将本单位在履行职责或者提供服务过程中获得的公民个人信息，出售或者非法提供给他人，情节严重的，处3年以下有期徒刑或者拘役，并处或者单处罚金。
  • 窃取或者以其他方法非法获取上述信息，情节严重的，依照前款的规定处罚。
  • 单位犯前两款罪的，对单位判处罚金，并对其直接负责的主管人员和其他直接责任人员，依照各该款的规定处罚。

最高人民法院、最高人民检察院关于执行《中华人民共和国刑法》确定罪名的补充规定（四）规定：触犯刑法第253条之一第1款之规定，构成“出售、非法提供公民个人信息罪”；触犯刑法第253条之一第2款之规定，构成“非法获取公民个人信息罪”

架构师素质

  • 《架构师画像》

    • 业务理解和抽象能力
    • NB的代码能力
    • 全面：1. 在面对业务问题上，架构师脑海里是否会浮现出多种技术方案；2. 在做系统设计时是否考虑到了足够多的方方面面；3. 在做系统设计时是否考虑到了足够多的方方面面；
    • 全局：是否考虑到了对上下游的系统的影响。
    • 权衡：权衡投入产出比；优先级和节奏控制；

  • 《关于架构优化和设计，架构师必须知道的事情》

    • 要去考虑的细节：模块化、轻耦合、无共享架构；减少各个组件之前的依赖、注意服务之间依赖所有造成的链式失败及影响等。
    • 基础设施、配置、测试、开发、运维综合考虑。
    • 考虑人、团队、和组织的影响。

  • 《如何才能真正的提高自己，成为一名出色的架构师？》

  • 《架构师的必备素质和成长途径》

    • 素质：业务理解、技术广度、技术深度、丰富经验、沟通能力、动手能力、美学素养。
    • 成长路径：2年积累知识、4年积累技能和组内影响力、7年积累部门内影响力、7年以上积累跨部门影响力。

  • 《架构设计师—你在哪层楼？》

    • 第一层的架构师看到的只是产品本身
    • 第二层的架构师不仅看到自己的产品，还看到了整体的方案
    • 第三层的架构师看到的是商业价值

团队管理

TODO

招聘

资讯

行业资讯

公众号列表

TODO

博客

团队博客

个人博客

综合门户、社区

国内：

国外：

问答、讨论类社区

行业数据分析

专项网站

其他类

推荐参考书

在线电子书

纸质书

开发方面

架构方面

技术管理方面

基础理论

工具方面

TODO

大数据方面

技术资源

开源资源

手册、文档、教程

国内：

  • W3Cschool

  • Runoob.com

    • HTML 、 CSS、XML、Java、Python、PHP、设计模式等入门手册。

  • Love2.io

    • 很多很多中文在线电子书，是一个全新的开源技术文档分享平台。
  • gitbook.cn
    • 付费电子书。
  • ApacheCN
    • AI、大数据方面系列中文文档。

国外：

在线课堂

会议、活动

活动发布平台:

常用APP

找工作

工具

代码托管

文件服务

  • 七牛
  • 又拍云

综合云服务商

VPS

]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>文章摘录自：<a href="https://github.com/xingshaocheng/architect-awesome" t 加密技术解析 https://www.mingyugu.com/encryption-analysis.html 2018-05-09T07:51:36.000Z 2018-05-09T07:51:36.000Z

本篇文章主要介绍一下常见的加密算法种类，并且解析一下各个算法的应用场景以及优缺利弊。

加密技术分类

首先，我们了解一下什么是加密技术？简单来说，加密技术就是利用技术手段把重要的数据变为乱码（加密），当需要使用时再用相同或不同的手段还原（解密）。我们常用加密技术通常分为两大类：”对称式”和”非对称式”，当然还有“散列算法”。

1.对称加密算法

对称式加密就是加密和解密使用同一个密钥。信息接收双方都需事先知道密匙和加解密算法且其密匙是相同的，之后便是对数据进行加解密了。对称加密算法用来对敏感数据等信息进行加密。

示意图
示意图

下面介绍一下主流的对称加密算法：

(1) DES

DES（Data Encryption Standard）：研究过加密的朋友十分熟悉，老牌的加密方法了。这是一个可逆的对称加密算法，也是应用最广泛的密钥系统。好像是从1977年美国政府开始采用的。大家都看过U-571吧，DES的思路就是参照二战时期盟军缴获的德军恩格玛加密机，不过DES比那个要牛多了。到现在为止，除了差分分析法和线性分析法外只有暴力穷举法了。前两种方法不是密码学家或数学家都不懂，不过穷举DES，以现有我们大家都可以掌握的技术手段，恐怕没个几百上千年下不来啊。不过，咱们破解不了，不能说明就没人或没有设备破解不了。正因为如此，所以才衍生出了3重DES加密。常规的DES密钥是64位的(实际上有8位是校验用)，而3DES是128位(当然有16位也是校验用)。增加密钥长度并增加运算量来防止破解，并在后来的AES出来之前确定为过度方案。不过现在即便有了AES，3DES也没少用，它依然很牛。

(2) 3DES

3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高。

(3) AES

AES（Advanced Encryption Standard）：高级加密标准，也叫Rijndael算法，是下一代的加密算法标准，用来代替原来的DES加密方法的，优点是速度快，安全级别高。。AES是一个使用128为分组块的分组加密算法，分组块和128、192或256位的密钥一起作为输入，对4×4的字节数组上进行操作。众所周之AES是种十分高效的算法，尤其在8位架构中，这源于它面向字节的设计。AES适用于8位的小型单片机或者普通的32位微处理器,并且适合用专门的硬件实现，硬件实现能够使其吞吐量（每秒可以到达的加密/解密bit数）达到十亿量级。同样，其也适用于RFID系统。

(4) Blowfish

它使用变长的密钥，长度可达448位，运行速度很快。

(5) RC2、RC4

对称算法，用变长密钥对大量数据进行加密，比DES快。

(6) RC6

RC6：有个算法RC4听说过吧，在无线传输和串行流传输的加密领域占有相当的分量。据说RC6是同一帮人研究出来的，不过它和RC4没太大关系啊。它是AES方案征集时的候选算法之一，但是没有Rijndael算法那么幸运。RC6据说可以抵抗所有已知的攻击，并能够提供AES所要求的安全性，它也是相当优秀的一种可逆加密算法。不过当初它为什么没能当选为AES算法就不得而知了，不知道当时有没有给评委们足够的商务费用啊。

(7) SM4

国家密码局的隐蔽不公开的商用算法，在国内民用和商用的，除这些都不容许使用外，其他的都可以使用

2.非对称加密算法

非对称式加密就是加密和解密所使用的不是同一个密钥，通常有两个密钥，称为”公钥”和”私钥”，它们两个必需配对使用，否则不能打开加密文件。发送双方A,B事先均生成一堆密匙，然后A将自己的公有密匙发送给B，B将自己的公有密匙发送给A，如果A要给B发送消 息，则先需要用B的公有密匙进行消息加密，然后发送给B端，此时B端再用自己的私有密匙进行消息解密，B向A发送消息时为同样的道理。

示意图
示意图

下面介绍一下主流的对称加密算法：

(1) RSA

RSA：由RSA公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的。RSA在国外早已进入实用阶段，已研制出多种高速的RSA的专用芯片。

(2) DSA

DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的DSS（数字签名标准），严格来说不算加密算法。

(3) ECC

ECC（Elliptic Curves Cryptography）：椭圆曲线密码编码学。ECC和RSA相比，具有多方面的绝对优势，主要有：抗攻击性强。相同的密钥长度，其抗攻击性要强很多倍。计算量小，处理速度快。ECC总的速度比RSA、DSA要快得多。存储空间占用小。ECC的密钥尺寸和系统参数与RSA、DSA相比要小得多，意味着它所占的存贮空间要小得多。这对于加密算法在IC卡上的应用具有特别重要的意义。带宽要求低。当对长消息进行加解密时，三类密码系统有相同的带宽要求，但应用于短消息时ECC带宽要求却低得多。带宽要求低使ECC在无线网络领域具有广泛的应用前景。

(4) Elgamal

(5) 背包算法

(6) Rabin

(7) D-H

(8) SM2

国家密码局的隐蔽不公开的商用算法，在国内民用和商用的，除这些都不容许使用外，其他的都可以使用

3.散列算法

散列算法，又称哈希函数，是一种单向加密算法。在信息安全技术中，经常需要验证消息的完整性，散列(Hash)函数提供了这一服务，它对不同长度的输入消息，产生固定长度的输出。这个固定长度的输出称为原输入消息的”散列”或”消息摘要”(Message digest)
。散列算法不算加密算法，因为其结果是不可逆的，既然是不可逆的，那么当然不是用来加密的，而是用于签名。主要用于验证，防止信息被修。具体用途如：文件校验、数字签名、鉴权协议等。下面介绍一下主流的散列算法：

(1) MD5

MD5：非常著名的哈希算法，不可逆算法。网站登录、操作系统的用户认证、文件完整性和数字签名等领域广泛应用。不可逆算法一般做的都比较绝，例如彩虹加密狗，只告诉你一个余数，你能知道原来的除数和被除数吗？只把运算过的数据相比较，而不非得知道原数据，这样就完成了认证过程。要想破解MD5的密码，即使采用现在最快的巨型计算机，据说也要运算100万年以上。不过，加密和解密都是数学领域的竞赛，每一种加密算法都或多或少的存在漏洞或缺陷，MD5看上去真那么牢不可破吗？和MD5同样有名的是山东大学的王小云教授。在2004年的国际密码大会上王小云宣布了她的研究小组完成了对MD5杂凑函数的杂凑冲撞，也就是从理论上说使用MD5的数字签名可以伪造。这也意味着MD5可能需要和其他加密算法共用才可以保证数字签名的安全。不过，说MD5已被破解，那也有些杞人忧天了。可以肯定的告诉你，网络上所有针对MD5提供的破解服务，全部都是查询用字典法暴力破解后的数据包，没有一个是真正伪造出来的数字签名，那些号称有几百亿条的记录对MD5庞大算法来说太小了。试想想，动用美国军方的巨型计算机，利用王小云研究理论，来破解我们的一个单片机或网站认证程序？没必要吧。所以MD5依然可用，只不过再加上3DES、AES或SHA来防止字典就更好了。

(2) SHA

SHA：SHA家族的五个算法，分别是SHA-1、SHA-224、SHA-256、SHA-384，和SHA-512，由美国国家安全局（NSA）所设计，并由美国国家标准与技术研究院（NIST）发布；是美国的政府标准。后四者有时并称为SHA-2。SHA-1在许多安全协定中广为使用，包括TLS和SSL、PGP、SSH、S/MIME和IPsec，曾被视为是MD5（更早之前被广为使用的杂凑函数）的后继者。但SHA-1和MD5一样，也被王小云教授找出杂凑冲撞的漏洞，并且在2017年Google也强势宣布成功攻破SHA-1加密，不过这些都是停留在理论上的，必经碰撞破解是要花费很高的代价的。举个栗子：“100个GPU大约需要计算一年，大概要花费几十万美元”，当然如果你有钱那也是可以的。不过话虽如此，使用SHA-256将是以后的趋势。

(3) HMAC

HMAC：是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code）,HMAC运算利用哈希算法，以一个密钥和一个消息为输入，生成一个消息摘要作为输出。也就是说HMAC是需要一个密钥的。所以，HMAC_SHA1也是需要一个密钥的，而SHA1不需要。

4.其他常用算法

(1) Base64

Base64：其实不是安全领域下的加密解密算法，只能算是一个编码算法，通常用于把二进制数据编码为可写的字符形式的数据，对数据内容进行编码来适合传输(可以对img图像编码用于传输)。这是一种可逆的编码方式。编码后的数据是一个字符串，其中包含的字符为：A-Z、a-z、0-9、+、/，共64个字符(26 + 26 + 10 + 1 + 1 = 64，其实是65个字符，“=”是填充字符。Base64要求把每三个8Bit的字节转换为四个6Bit的字节(38 = 46 = 24)，然后把6Bit再添两位高位0，组成四个8Bit的字节，也就是说，转换后的字符串理论上将要比原来的长1/3。原文的字节最后不够3个的地方用0来补足，转换时Base64编码用=号来代替。这就是为什么有些Base64编码会以一个或两个等号结束的原因，中间是不可能出现等号的，但等号最多只有两个。其实不用”=”也不耽误解码，之所以用”=”，可能是考虑到多段编码后的Base64字符串拼起来也不会引起混淆。)

Base64编码是从二进制到字符的过程，像一些中文字符用不同的编码转为二进制时，产生的二进制是不一样的，所以最终产生Base64字符也不一样。例如”上网”对应UTF-8格式的Base64编码是”5LiK572R”，对应GB2312格式的Base64编码是”yc/N+A==”。

标准的Base64并不适合直接放在URL里传输，因为URL编码器会把标准Base64中的“/”和“+”字符变为形如“%XX”的形式，而这些“%”号在存入数据库时还需要再进行转换，因为ANSI SQL中已将“%”号用作通配符。为解决此问题，可采用一种用于URL的改进Base64编码，它不在末尾填充’=’号，并将标准Base64中的“+”和“/”分别改成了“-”和“”，这样就免去了在URL编解码和数据库存储时所要作的转换，避免了编码信息长度在此过程中的增加，并统一了数据库、表单等处对象标识符的格式。另有一种用于正则表达式的改进Base64变种，它将“+”和“/”改成了“!”和“-”，因为“+”，“*”以及前面在IRCu中用到的“[”和“]”在正则表达式中都可能具有特殊含义。此外还有一些变种，它们将“+/”改为“-”或“.”（用作编程语言中的标识符名称）或“.-”（用于XML中的Nmtoken）甚至“:”（用于XML中的Name）。

(2) TEA

TEA：它是一种分组加密算法，也是可逆算法。短小精悍。它的实现非常简单，超不过10行代码。TEA算法每一次可以操作64位(8字节)，采用128位(16字节)作为密钥，算法采用迭代的形式，尽管32轮迭代已经足够了，但是最好的迭代轮数是64轮。数据流加密可能比较适合，因为据说早期的QQ采用过TEA加密算法。

加密算法比较

1.对称加密算法(加解密密钥相同)

名称密钥长度运算速度安全性资源消耗
DES56位较快低中
3DES112位或168位慢中高
AES128、192、256位快高低

2.非对称算法（加密密钥和解密密钥不同）

名称成熟度安全性(取决于密钥长度)运算速度资源消耗
RSA高高慢高
DSA高高慢只能用于数字签名
ECC低高快低（计算量小,存储空间占用小,带宽要求低）

3.散列算法

名称安全性速度
SHA-1高慢
MD5中快

4.对称与非对称算法

名称密钥管理安全性速度
对称算法比较难,不适合互联网,一般用于内部系统中快，好几个数量级(软件加解密速度至少快100倍,每秒可以加解密数M比特数据),适合大数据量的加解密处
非对称算法密钥容易管理高慢，适合小数据量加解密或数据签名

加密算法选择（从性能和安全性综合）

对称加密：AES(128位)

非对称加密：ECC(160位)、RSA(1024)

消息摘要：MD5

数字签名：DSA

速度排名（估测，未验证）：IDEA<DES<GASTI28<GOST<AES<RC4<TEA<Blowfish

总结

  1. 加密算法是可逆的，用来对敏感数据进行保护。散列算法(签名算法、哈希算法)是不可逆的，主要用于身份验证。
  2. 对称加密算法使用同一个密匙加密和解密，速度快，适合给大量数据加密。对称加密客户端和服务端使用同一个密匙，存在被抓包破解的风险。
  3. 非对称加密算法使用公钥加密，私钥解密，私钥签名，公钥验签。安全性比对称加密高，但速度较慢。非对称加密使用两个密匙，服务端和客户端密匙不一样，私钥放在服务端，黑客一般是拿不到的，安全性高。
  4. Base64不是安全领域下的加解密算法，只是一个编码算法，通常用于把二进制数据编码为可写的字符形式的数据，特别适合在http，mime协议下的网络快速传输数据。UTF-8和GBK中文的Base64编码结果是不同的。采用Base64
    编码不仅比较简短，同时也具有不可读性，即所编码的数据不会被人用肉眼所直接看到，但这种方式很初级，很简单。Base64可以对图片文件进行编码传输。
  5. https协议广泛用于万维网上安全敏感的通讯，例如交易支付方面。它的主要作用可以分为两种：一种是建立一个信息安全通道，来保证数据传输的安全；另一种就是确认网站的真实性。
  6. 大量数据加密建议采用对称加密算法，提高加解密速度；小量的机密数据，可以采用非对称加密算法。在实际的操作过程中，我们通常采用的方式是：采用非对称加密算法管理对称算法的密钥，然后用对称加密算法加密数据，这样我们就集成了两类加密算法的优点，既实现了加密速度快的优点，又实现了安全方便管理密钥的优点。
  7. MD5标准密钥长度128位（128位是指二进制位。二进制太长，所以一般都改写成16进制，每一位16进制数可以代替4位二进制数，所以128位二进制数写成16进制就变成了128/4=32位。16位加密就是从32位MD5散列中把中间16位提取出来）；sha1标准密钥长度160
    位(比MD5摘要长32位)，Base64转换后的字符串理论上将要比原来的长1/3。
]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>本篇文章主要介绍一下常见的加密算法种类，并且解析一下各个算法的应用场景以及优缺利弊。</p><hr><h1 id="加密技术分类"><a Java动态加载数据库驱动 https://www.mingyugu.com/java-dyna-load-db-drv.html 2018-05-07T08:41:12.000Z 2018-05-07T08:41:12.000Z

本篇文章主要介绍了JDBC驱动注册的几种常用方式和Java是如何动态的加载并注册多个JDBC数据库驱动的。

JDBC驱动注册

JDBC提供了独立于数据库的统一API，MySQL、Oracle等数据库公司都可以基于这个标准接口来进行开发。包括java .sql包下的Driver、Connection、Statement、ResultSet是JDBC提供的接口。而DriverManager是用于管理JDBC驱动的服务类，主要用于获取Connection对象（此类中全是静态方法）。

当我们查看API，在Driver接口中，明确要求：Driver接口是每个驱动程序类必须实现的接口。Java SQL框架允许多个数据库驱动程序。每个驱动程序都应该提供一个实现Driver接口的类。并且明确：在加载某一Driver类时，它应该创建自己的实例并向 DriverManager注册该实例。因此，我们有了以下三种常用的使用方法：

1.反射

1
Class.forName("com.mysql.jdbc.Driver");

这种方式是不是很眼熟，相信这种也是大家最常见和最常用的方式了，而且我一般也推荐使用这种方式，不会对具体的驱动类产生依赖（就是不用import package了）。

2.DriverManager

1
2
Driver driver = new Driver(); //com.mysql.jdbc.Driver  
DriverManager.registerDriver(driver);

或

1
DriverManager.registerDriver(new com.mysql.jdbc.Driver());

这种方式会造成DriverManager中产生两个一样的驱动(其实就是实例化了两次)，并会对具体的驱动类产生依赖。正常情况下我是不推荐使用的，但是在特定需求下还是很有作用的，具体的我会在后面详叙。

3.系统属性

1
System.setProperty("jdbc.drivers","com.mysql.jdbc.Driver");

这种方式是通过系统的属性设置注册驱动，如果要注册多个驱动，则System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver:com.oracle.jdbc.Driver");，虽然不会对具体的驱动类产生依赖；但注册不太方便，所以很少使用。

4.综合分析

上面我们说了三种常用的JDBC驱动的注册方式，其中因为第三种很少使用，所以我们就不过多讨论了，这里我们主要来对比一下第一种和第二种注册方式的异同。这两种注册方式有什么不同呢？第一种方式是利用反射机制来完成的，直接看的话，我们会想Class.forName (driverClass)只能帮助我们得到Driver的Class对象啊，为什么会帮我们完成注册了呢。从上边对Driver()的API的查阅，API
要求：在加载某一Driver类时，它应该创建自己的实例并向DriverManager注册该实例。所以我们猜想是在类加载时，就自动完成了注册。而第二种方式，相对比较好理解，就是先创建数据库驱动，然后调用registerDriver()方法完成注册。下边去具体看一下源码来分析一下：

第一种方式，这种方式是怎么通过只要获得Driver的Class对象就可以完成注册呢，下边看一下其com.mysql.jdbc.Driver 的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    // ~ Static fields/initializers    
    // ---------------------------------------------    
    //    
    // Register ourselves with the DriverManager    
    //    
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        }
        catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

从上边可以看到，它是用静态代码块实现的。根据类加载机制，当执行Class.forName(driverClass)获取其Class对象时，com.mysql.jdbc.Driver就会被JVM加载连接，并进行初始化，初始化就会执行静态代码块，也就会执行下边这句代码：

1
java.sql.DriverManager.registerDriver(new Driver());

大家有没有发现这已经和第二种方式一样了，所以有没有想到点什么(￣︶￣)

第二种方法，我们看下JDK1.7下的DriverManger的registerDriver()方法：

1
2
3
4
5
6
7
8
9
10
11
public static synchronized void registerDriver(java.sql.Driver driver) 
    throws SQLException {
    /* Register the driver if it has not already been added to our list */
    if(driver != null) {
        registeredDrivers.addIfAbsent(new DriverInfo(driver));
    } else {
        // This is for compatibility with the original DriverManager  
        throw new NullPointerException();
    }
    println("registerDriver:" + driver);
}

从其源码，可以看到DriverManger将要注册的驱动程序信息封装到了DriverInfo中，然后放进了一个List中。在后边获得连接时会再用到。

1
2
// List of registered JDBC drivers  
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<DriverInfo>();

Ok，分析完两种方式后，相信聪明的童鞋已经知道了结果。这里我们在总结一下，对于上边的两种驱动注册方式，我们一般采用第一种方式，因为第二种方式有以下两个问题：

（1）由于实例化了com.mysql.jdbc.Driver.class，导致必须导入该类(就是要把这个类import进去)，从而具体驱动产生了依赖，不方便扩展代码。

（2）DriverManager.registerDriver(new com.mysql.jdbc.Driver());，实例化的时候注册了一次，加载的时候其在内部也执行静态代码块，这相当于实例化了两个Driver对象。

动态加载JDBC驱动

1.问题背景

在同一套系统中，要支持连接访问各种流行的数据库，以及同一数据库的不同版本，例如：Oracle 9i、Oracle 10g、Oracle 11g、Oracle 12c、SQL Server 2000、SQL Server 2005、SQL Server 2008、SQL Server 2012等，其中就会碰到一些问题，就是不同的数据库，数据库驱动肯定不同，对于这个问题到好解决，只需要将相应的驱动加入即可。然而对于同种数据库，不同版本时，而且不同版本的数据库驱动不仅不兼容，同时存在还会出现冲突，例如，能满足SQL Server 2000的驱动，就不能满足SQL Server 2012，而能满足SQL Server 2012的驱动，就不能满足SQL Server 2000。对于这种问题，面前能想到的解决方案就是动态加载数据库驱动，当用到某种数据库时，就加载其对应的数据库驱动，使用完以后就卸载驱动。

2.代码实现

在此只列出核心代码，就是动态加载数据库驱动的类，只是此处暂时没有考虑到数据库连接池的问题，当选择动态加载数据库驱动时，数据库连接池需要自己实现。这里只是提供了一个思路，并不一定是最优实现。

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
package com.mygu.dynamic.service.impl;
import com.mygu.dynamic.model.DataSourceInfo;
import com.mygu.dynamic.service.IDynamicLoaderService;
import org.springframework.stereotype.Service;
import java.net.URL;
import java.net.URLClassLoader;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import javax.annotation.PostConstruct;
/**
 * 动态加载JDBC数据库驱动服务类
 */
@Service
public class DynamicLoaderService implements IDynamicLoaderService {
    // 保存数据库连接信息
    private Map<String, DataSourceInfo> dataSourceInfos = null;
    // 保存数据库相应驱动JAR的路径
    private Map<String, String> paths = null;
    // 缓存对应的Driver对象
    private Map<String, Driver> drivers = null;
    private URLClassLoader classLoader;
    /**
    * 初始化方法
    *
    * @throws Exception
    */
    @PostConstruct
        public void init() throws Exception {
        dataSourceInfos = new HashMap<String, DataSourceInfo>();
        // 此处只已Oracle 9i和Oracle 10g为例，其它数据库信息同理的方式增加即可
        DataSourceInfo oracle9Info = new DataSourceInfo();
        oracle9Info.setDriver("oracle.jdbc.driver.OracleDriver");
        oracle9Info.setUrl("jdbc:oracle:thin:@192.168.0.101:1521:ORACLE");
        oracle9Info.setUsername("system");
        oracle9Info.setPassword("system");
        dataSourceInfos.put("oracle9", oracle9Info);
        DataSourceInfo oracle10Info = new DataSourceInfo();
        oracle10Info.setDriver("oracle.jdbc.driver.OracleDriver");
        oracle10Info.setUrl("jdbc:oracle:thin:@192.168.0.102:1521:orcl");
        oracle10Info.setUsername("system");
        oracle10Info.setPassword("system");
        dataSourceInfos.put("oracle10", oracle10Info);
        // 将数据库对应驱动jar放置容器中
        paths = new HashMap<String, String>();
        paths.put("oracle9", "/driver/ojdbc6.jar");
        paths.put("oracle10", "/driver/ojdbc14.jar");
        // 初始化drivers
        drivers = new HashMap<String, Driver>();
    }
    @Override
        public Connection getConnection(String dbType) throws Exception {
        Connection conn = null;
        Driver driver = drivers.get(dbType);
        DataSourceInfo dataSourceInfo = dataSourceInfos.get(dbType);
        if (driver == null) {
            URL jarUrl = this.getClass().getResource(paths.get(dbType));
            classLoader = new URLClassLoader(new URL[] { jarUrl });
            Class<?> driverClass = classLoader.loadClass(dataSourceInfo.getDriver());
            driver = (Driver) driverClass.newInstance();
            drivers.put(dbType, driver);
        }
        // 注册驱动
        DriverManager.registerDriver(driver);
        Properties properties = new Properties();
        properties.put("user", dataSourceInfo.getUsername());
        properties.put("password", dataSourceInfo.getPassword());
        conn = DriverManager.getConnection(dataSourceInfo.getUrl(), properties);
        // 卸载驱动
        DriverManager.deregisterDriver(driver);
        return conn;
    }
}

3.其他方案

上面提供了一个自己如何通过动态注册和卸载JDBC驱动的方式来实现的思路，并且没有实现连接池。其实在现在很多开源的数据库连接池的框架中，已经自带实现了动态数据源的注册和卸载，并且还包含SQL的使用工具、性能监测等很多功能。如果想详细了解的话，这里我推荐一个阿里开源的Druid连接池框架，这是一个支持多线程和异步的连接池框架，比之其他开源的主流连接池，例如C3P0、DBCP等单线程框架性能和可扩展性都要好很多，有兴趣的可以深入了解一下。

]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>本篇文章主要介绍了<code>JDBC</code>驱动注册的几种常用方式和<code>Java</code>是如何动态的加载并注册多个 喀麦隆贸易便利化项目文档（cntfecs） https://www.mingyugu.com/centfecs-doc.html 2018-04-08T03:13:11.000Z 2018-04-08T03:13:11.000Z
]]> 此文章已经加密，需要解密后才能阅读</br> RedHat Nginx自启动配置 https://www.mingyugu.com/redhat-nginx-auto-startup.html 2018-02-26T02:38:18.000Z 2018-02-26T02:38:18.000Z

在本文档中，描述如何在RedHat操作系统上设置Nginx自启动

设置文件的访问权限

a+x ==> all user can execute 所有用户可执行

1
$ chmod a+x /etc/init.d/nginx

设置自启动

将命令加入到rc.local文件中，这样开机的时候nginx就默认启动了，通过以下vi命令打开编辑

1
$ vi /etc/rc.local

并加入一行以下代码，保存并退出，下次重启会生效

1
/etc/init.d/nginx start
]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>在本文档中，描述如何在<code>RedHat</code>操作系统上设置<code>Nginx</code>自启动</p><hr><h Windows下配置Node环境 https://www.mingyugu.com/windows-node-settings.html 2017-06-14T01:47:32.000Z 2017-06-14T01:47:32.000Z

此文档主要简述如何在windows（本文使用的是windows7 64位操作系统)下配置Node环境并运行NiceFish项目(基于Angular2的开源项目)：

安装WebStorm（前端开发IDE）

官网地址：https://www.jetbrains.com/webstorm/

(1) 注册码

因为WebStorm是收费软件，下面是开源社区提供的注册码（如果有能力希望支持付费正版）。如果注册失败，请添加0.0.0.0 account.jetbrains.com到hosts(C:\Windows\System32\drivers\etc)

1
EB101IWSWD-eyJsaWNlbnNlSWQiOiJFQjEwMUlXU1dEIiwibGljZW5zZWVOYW1lIjoibGFuIHl1IiwiYXNzaWduZWVOYW1lIjoiIiwiYXNzaWduZWVFbWFpbCI6IiIsImxpY2Vuc2VSZXN0cmljdGlvbiI6IkZvciBlZHVjYXRpb25hbCB1c2Ugb25seSIsImNoZWNrQ29uY3VycmVudFVzZSI6ZmFsc2UsInByb2R1Y3RzIjpbeyJjb2RlIjoiSUkiLCJwYWlkVXBUbyI6IjIwMTgtMTAtMTQifSx7ImNvZGUiOiJSUzAiLCJwYWlkVXBUbyI6IjIwMTgtMTAtMTQifSx7ImNvZGUiOiJXUyIsInBhaWRVcFRvIjoiMjAxOC0xMC0xNCJ9LHsiY29kZSI6IlJEIiwicGFpZFVwVG8iOiIyMDE4LTEwLTE0In0seyJjb2RlIjoiUkMiLCJwYWlkVXBUbyI6IjIwMTgtMTAtMTQifSx7ImNvZGUiOiJEQyIsInBhaWRVcFRvIjoiMjAxOC0xMC0xNCJ9LHsiY29kZSI6IkRCIiwicGFpZFVwVG8iOiIyMDE4LTEwLTE0In0seyJjb2RlIjoiUk0iLCJwYWlkVXBUbyI6IjIwMTgtMTAtMTQifSx7ImNvZGUiOiJETSIsInBhaWRVcFRvIjoiMjAxOC0xMC0xNCJ9LHsiY29kZSI6IkFDIiwicGFpZFVwVG8iOiIyMDE4LTEwLTE0In0seyJjb2RlIjoiRFBOIiwicGFpZFVwVG8iOiIyMDE4LTEwLTE0In0seyJjb2RlIjoiUFMiLCJwYWlkVXBUbyI6IjIwMTgtMTAtMTQifSx7ImNvZGUiOiJDTCIsInBhaWRVcFRvIjoiMjAxOC0xMC0xNCJ9LHsiY29kZSI6IlBDIiwicGFpZFVwVG8iOiIyMDE4LTEwLTE0In0seyJjb2RlIjoiUlNVIiwicGFpZFVwVG8iOiIyMDE4LTEwLTE0In1dLCJoYXNoIjoiNjk0NDAzMi8wIiwiZ3JhY2VQZXJpb2REYXlzIjowLCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2V9-Gbb7jeR8JWOVxdUFaXfJzVU/O7c7xHQyaidCnhYLp7v32zdeXiHUU7vlrrm5y9ZX0lmQk3plCCsW+phrC9gGAPd6WDKhkal10qVNg0larCR2tQ3u8jfv1t2JAvWrMOJfFG9kKsJuw1P4TozZ/E7Qvj1cupf/rldhoOmaXMyABxNN1af1RV3bVhe4FFZe0p7xlIJF/ctZkFK62HYmh8V3AyhUNTzrvK2k+t/tlDJz2LnW7nYttBLHld8LabPlEEjpTHswhzlthzhVqALIgvF0uNbIJ5Uwpb7NqR4U/2ob0Z+FIcRpFUIAHEAw+RLGwkCge5DyZKfx+RoRJ/In4q/UpA==-MIIEPjCCAiagAwIBAgIBBTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTE1MTEwMjA4MjE0OFoXDTE4MTEwMTA4MjE0OFowETEPMA0GA1UEAwwGcHJvZDN5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxcQkq+zdxlR2mmRYBPzGbUNdMN6OaXiXzxIWtMEkrJMO/5oUfQJbLLuMSMK0QHFmaI37WShyxZcfRCidwXjot4zmNBKnlyHodDij/78TmVqFl8nOeD5+07B8VEaIu7c3E1N+e1doC6wht4I4+IEmtsPAdoaj5WCQVQbrI8KeT8M9VcBIWX7fD0fhexfg3ZRt0xqwMcXGNp3DdJHiO0rCdU+Itv7EmtnSVq9jBG1usMSFvMowR25mju2JcPFp1+I4ZI+FqgR8gyG8oiNDyNEoAbsR3lOpI7grUYSvkB/xVy/VoklPCK2h0f0GJxFjnye8NT1PAywoyl7RmiAVRE/EKwIDAQABo4GZMIGWMAkGA1UdEwQCMAAwHQYDVR0OBBYEFGEpG9oZGcfLMGNBkY7SgHiMGgTcMEgGA1UdIwRBMD+AFKOetkhnQhI2Qb1t4Lm0oFKLl/GzoRykGjAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBggkA0myxg7KDeeEwEwYDVR0lBAwwCgYIKwYBBQUHAwEwCwYDVR0PBAQDAgWgMA0GCSqGSIb3DQEBCwUAA4ICAQC9WZuYgQedSuOc5TOUSrRigMw4/+wuC5EtZBfvdl4HT/8vzMW/oUlIP4YCvA0XKyBaCJ2iX+ZCDKoPfiYXiaSiH+HxAPV6J79vvouxKrWg2XV6ShFtPLP+0gPdGq3x9R3+kJbmAm8w+FOdlWqAfJrLvpzMGNeDU14YGXiZ9bVzmIQbwrBA+c/F4tlK/DV07dsNExihqFoibnqDiVNTGombaU2dDup2gwKdL81ua8EIcGNExHe82kjF4zwfadHk3bQVvbfdAwxcDy4xBjs3L4raPLU3yenSzr/OEur1+jfOxnQSmEcMXKXgrAQ9U55gwjcOFKrgOxEdek/Sk1VfOjvS+nuM4eyEruFMfaZHzoQiuw4IqgGc45ohFH0UUyjYcuFxxDSU9lMCv8qdHKm+wnPRb0l9l5vXsCBDuhAGYD6ss+Ga+aDY6f/qXZuUCEUOH3QUNbbCUlviSz6+GiRnt1kA9N2Qachl+2yBfaqUqr8h7Z2gsx5LcIf5kYNsqJ0GavXTVyWh7PYiKX4bs354ZQLUwwa/cG++2+wNWP+HtBhVxMRNTdVhSm38AknZlD+PTAsWGu9GyLmhti2EnVwGybSD2Dxmhxk3IPCkhKAK+pl0eWYGZWG3tJ9mZ7SowcXLWDFAk0lRJnKGFMTggrWjV8GYpw5bq23VmIqqDLgkNzuoog==
示例图
示例图

安装配置Node环境

(1) 安装nvm（Node Version Manager）

GitHup主页：https://github.com/coreybutler/nvm-windows
nvm-windows下载地址：https://github.com/coreybutler/nvm-windows
安装过程比较简单，安装完成后到安装目录（默认是C:\Users\GMY\AppData\Roaming\nvm），修改settings.txt文件如下（根据自己的安装目录稍作修改）：

1
2
3
4
5
6
root: C:\Users\GMY\AppData\Roaming\nvm 
path: C:\Program Files\nodejs 
arch: 64 
proxy: none
node_mirror: http://npm.taobao.org/mirrors/node/ 
npm_mirror: https://npm.taobao.org/mirrors/npm/

验证nvm是否安装成功，可以运行如下命令，并且查看环境变量中是否已经自动创建了NVM_HOME和NVM_SYSLINK

1
$ nvm version

(2) 安装node和npm

使用nvm安装node（V6.9.0），安装node的同时会绑定安装npm（Node Package Manager）

1
2
3
4
5
$ nvm install v6.9.0
$ nvm list
$ nvm use 6.9.0
$ node --version
$ npm --version

(3) 安装全局的npm

配置全局的npm安装包路径

1
$ npm config set prefix "C:\Users\GMY\AppData\Roaming\nvm"

然后安装全局的最新npm

1
2
$ npm install -i -g npm
$ npm --version

安装完成后需要配置环境变量NPM_HOME=C:\Users\GMY\AppData\Roaming\nvm\npm并添加%NPM_HOME%到path，如下图所示：

示例图
示例图

安装cnpm（淘宝的国内npm镜像）

因为国内的环境所以我们需要一个国内的镜像，不然后面通过npm安装相关的包会非常的慢并且可能安装不上

1
2
$ npm install -i -g cnpm
$ cnpm --version

配置并运行NiceFish项目（Angular2）

(1) 安装angular-cli脚手架

通过我们安装的cnpm安装angular-cli脚手架（这里需要注意的是如果使用原生的npm安装会有一切环境问题，比如需要安装python环境和visual studio环境等，所以建议使用cnpm安装）

1
2
3
4
$ npm uninstall -g angular-cli
$ npm uninstall -g @angular/cli
$ cnpm install -i -g @angular/cli
$ ng --version
示例图
示例图

(2) 克隆NiceFish项目到本地

因为NiceFish这个项目在开源中国的码云上，所以需要使用git来克隆项目。这里推荐一个取代windows下cmd的工具cmder（http://cmder.net/），可以去官网下载并安装，如果你安装了`cmder`，里面已经集成安装了`Git`，所以可以直接执行下面的命令。

如果你并不想使用cmder，而仍然青睐于cmd的话，那你就需要单独安装Git（https://git-for-windows.github.io/），安装完成后执行如下命令：

1
2
3
$ E:
$ cd WebstormProjects\
$ git clone https://git.oschina.net/mumu-osc/NiceFish.git

(3) 安装NiceFish项目的依赖包

我们已经克隆的项目在E:\WebstormProjects\NiceFish，接下来我们需要安装这个项目的依赖包

1
2
3
$ E:
$ cd WebstormProjects\NiceFish\
$ cnpm install

(4) 编译运行NiceFish项目

使用ng命令编译运行项目，这个编译过程会比较慢，大概需要1分多钟，耐心等待就好了

1
$ ng serve --prod --aot

如果你看到如下图所示，那么恭喜你已经完成了全部node配置并且成功运行了一个Angular2的项目。现在打开浏览器访问http://localhost:4200，就可以访问项目了，Enjoy！

示例图
示例图
]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>此文档主要简述如何在<code>windows</code>（本文使用的是<code>windows7</code> 64位操作系统)下 Cogitr服务器相关文档(Cogitr server documents) https://www.mingyugu.com/cogitr-server-doc.html 2016-12-18T05:45:44.000Z 2016-12-18T05:45:44.000Z
]]> 此文章已经加密，需要解密后才能阅读</br> CentOS配置文档 https://www.mingyugu.com/centos-settings.html 2016-12-12T06:32:25.000Z 2016-12-12T06:32:25.000Z

此文档主要简述在阿里云安装CentOS并配置相关运行环境：

服务器信息

系统：centos 7 (自带python 2.7.5)

服务器配置

1. 配置免密码登录

(1) 本机生成rsa密钥

在本机生成rsa加密的密钥，下面命令会在指定的目录生成一个私有和一个公有rsa密钥，将私有密钥保存好，等配置好免密码登录后，登录服务器时将需要此文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$ ssh-keygen -f ~/temp/ljflxxglpt.pem
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/gmy/temp/ljflxxglpt.pem.
Your public key has been saved in /home/gmy/temp/ljflxxglpt.pub.
The key fingerprint is:
7a:9c:b2:9c:8e:4e:f4:af:de:70:77:b9:52:fd:44:97 personalid
The key's randomart image is:
+--[ RSA 2048]----+
|         |
|         |
|        .|
|        Eo|
|  .  S  . ..|
|  . . o . ... .|
|  . = = ..o o |
|  . o X ... . .|
|  .ooB.o ..  |
+-----------------+

(2) 登录服务器

第一次登录使用用户名密码的方式

1
$ ssh root@120.27.140.104

(3) 服务器生成rsa密钥

服务器生成rsa密钥，主要目的是为了生成ssh目录以及后面从代码仓库clone代码的权限问题。生成的ssh目录变更权限为所有者可读写(700)，目的是为了配置免密码登录服务器

1
2
$ ssh-keygen
$ chmod 700 ~/.ssh

(4) 上传本机公有密钥到服务器

把刚刚在本机生成的公有密钥上传到服务器并添加到authorized_keys中

1
$ scp ~/temp/ljflxxglpt.pub root@120.27.140.230:~/.ssh/authorized_keys

(5) 使用密钥登录服务器

使用本机的私有密钥登录已经存储过本机公有密钥的服务器

1
$ ssh -i ~/temp/ljflxxglpt.pem root@120.27.140.230

(6) 关闭密码登录

关闭密码登录只使用密钥登录可以防止暴力破解，设置完成后重启服务器

1
2
$ vi /etc/ssh/sshd_config
#PasswordAuthentication yes > PasswordAuthentication no

2. 服务器安装部署

(1) 更新系统

1
sudo yum update -y

(2) 安装系统运行必备库

1
2
3
$ sudo yum install gcc git libtiff-devel libjpeg-devel libzip-devel freetype-devel
lcms2-devel libwebp-devel tcl-devel tk-devel mysql mysql-devel memcached libmemcacheddevel
nginx mysql-devel python-devel libffi-devel  -y

(3) 克隆项目

添加服务器生成的公有密钥到代码仓库，然后运行git命令clone项目将不需要权限验证

1
$ cat ~/.ssh/id_rsa.pub
服务器公钥
服务器公钥
仓库添加公钥
仓库添加公钥
1
$ git clone git@bitbucket.org:mingyugu/ljflxxglpt-api.git

(4) 创建Python虚拟环境

1
2
3
$ sudo easy_install virtualenv
$ virtualenv env
$ source env/bin/activate

(5) 安装项目依赖库

克隆项目到服务器后需要安装项目依赖库

1
2
$ cd ~/ljflxxglpt-api/
$ pip install -r requirements.txt

(6) 安装数据库环境

MySQL是一个关系型数据库管理系统，安装可以参考以下链接

http://www.mysql.com/downloads/

PostgreSQL是以加州大学伯克利分校计算机系开发的POSTGRES，现在已经更名为PostgreSQL，版本4.2为基础的对象关系型数据库管理系统（ORDBMS）。PostgreSQL支持大部分SQL标准并且提供了许多其他现代特性：复杂查询、外键、触发器、视图、事务完整性、MVCC。同样，PostgreSQL可以用许多方法扩展，比如，通过增加新的数据类型、函数、操作符、聚集函数、索引。免费使用、修改、和分发 PostgreSQL，不管是私用、商用、还是学术研究使用。

http://www.postgresql.org/download/linux/redhat/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ yum install postgresql-server
$ yum install postgresql-devel
$ service postgresql initdb
$ chkconfig postgresql on
$ sudo -u postgres psql
postgres=# \password postgres
postgres=# CREATE USER lettoo_base_api WITH PASSWORD 'password';
postgres=# CREATE DATABASE lettoo_base_api OWNER lettoo_base_api;
postgres=# GRANT ALL PRIVILEGES ON DATABASE lettoo_base_api to lettoo_base_api;
postgres=# \du
postgres=# \q
$ exit
$ vi /var/lib/pgsql/data/pg_hba.conf
localallallpeer > localallallmd5
$ systemctl restart postgresql.service
$ psql -U lettoo_base_api -d lettoo_base_api

(7) 创建mysql数据库

1
2
3
4
5
mysql> DROP DATABASE ljflxxglpt;
mysql> CREATE DATABASE ljflxxglpt CHARACTER SET utf8;
mysql> GRANT ALL PRIVILEGES ON ljflxxglpt.* TO "ljflxxglpt"@"%" IDENTIFIED BY "password";
mysql> FLUSH PRIVILEGES;
mysql> EXIT;

(8) 配置项目依赖的环境变量

1
$ vi ~/.bashrc

添加以下配置

export ALIYUN_OSS_ACCESS_KEY_ID=’mjpa3WKngENt5ijN’
export ALIYUN_OSS_ACCESS_KEY_SECRET=’0XdA1bgi3eAV5usbiWqaAtI7QlbtaJ’
export ALIYUN_OSS_BUCKET_NAME=’ljflxxglpt’
export ALIYUN_OSS_ACCESS_HOST=’ljflxxglpt.oss-cn-hangzhou-internal.aliyuncs.com’
export DATABASE_URL=’mysql://ljflxxglpt:password@rds68fqj481t1m274fg2.mysql.rds.aliyuncs.com:3306/ljflxxglpt’
export DJANGO_SECRET_KEY=’51c3184f-0168-4314-b707-352b48578eb7’
export EMAIL_USERNAME='ljflxxglpt@163.com‘
export EMAIL_PASSWORD=’ljflxxglpt123456’

让系统即刻刷新环境变量

1
$ source ~/.bashrc

(9) 同步数据库

1
2
$ python manage.py syncdb --settings=config.settings.production
$ python manage.py migrate --settings=config.settings.production

(10) 收集静态文件

1
$ python manage.py collectstatic --settings=config.settings.production

(11) 安装nginx

下载对应当前系统版本的nginx包(package)

1
$ wget  http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm

建立nginx的yum仓库

1
$ rpm -ivh nginx-release-centos-7-0.el7.ngx.noarch.rpm

下载并安装nginx

1
$ yum install nginx

(12) 配置supervisor/nginx/uWSGI

1
2
3
$ mkdir ~/logs
$ sudo cp etc/nginx_ljflxxglpt_*.conf /etc/nginx/conf.d/
$ supervisord

检查supervisor service

1
$ supervisorctl

重启nginx

1
$ sudo service nginx restart

web服务器配置

(1) 安装node.js

参考官方教程：https://nodejs.org/en/download/package-manager/

1
2
3
4
$ curl --silent --location https://rpm.nodesource.com/setup | bash -
$ yum -y install nodejs
$ yum install gcc-c++ make
# or: yum groupinstall 'Development Tools'

(2) 安装npm

新版本的node.js已经自带了npm所以这步可以省略
https://nodejs.org/en/download/

1
$ sudo yum install npm

(3) 安装bower

1
$ sudo npm install -g bower

(4) 安装gulp

1
$ sudo npm install -g gulp

(5) 安装node modules

1
$ npm install

(6) 安装bower components

1
$ bower install --allow-root

(7) 编译

测试环境

1
$ gulp serve:dev

生产环境

1
$ gulp serve:prod

3. 服务器supervisord自启动

(1) 拷贝supervisord文件到/etc/rc.d/init.d/supervisord

1
$ sudo cp supervisord /etc/rc.d/init.d/supervisord

(2) 改变supervisord文件全选为可执行

1
$ sudo chmod +x /etc/rc.d/init.d/supervisord

(3) 添加自启动

1
$ sudo chkconfig supervisord on

(4) 手动启动supervisord

1
$ sudo service supervisord start

(5) centos 7 nginx自动启动

1
2
$ systemctl list-unit-files
$ systemctl enable nginx.service

4. 服务器常见问题

(1) nginx 403 Forbidden errors

通常显示403立马都会想到路径配置不对，但是如果检查后发现目录路径没问题那么就是权限问题。修改nginx.conf，头部修改’user root;’，然后重启nginx

1
2
$ vi /etc/nginx/nginx.conf
user root;
]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>此文档主要简述在阿里云安装CentOS并配置相关运行环境：</p><hr><h1 id="服务器信息"><a href="#服务器信息" 垃圾袋称重箱和云服务器数据交互接口协议 https://www.mingyugu.com/garbage-weighing-api-doc.html 2016-06-26T13:31:58.000Z 2016-06-26T13:31:58.000Z
]]> 此文章已经加密，需要解密后才能阅读</br> 垃圾袋发放机和云服务器数据交互接口协议 https://www.mingyugu.com/garbage-dispenser-api-doc.html 2016-05-21T06:28:32.000Z 2016-05-21T06:28:32.000Z
]]> 此文章已经加密，需要解密后才能阅读</br> 垃圾袋分类箱和云服务器数据交互接口协议 https://www.mingyugu.com/garbage-sorting-api-doc.html 2016-05-21T06:28:32.000Z 2016-05-21T06:28:32.000Z
]]> 此文章已经加密，需要解密后才能阅读</br> 使用Nginx + Let's Encrypt配置免费的HTTPS https://www.mingyugu.com/nginx-free-https.html 2016-03-17T01:13:02.000Z 2016-03-17T01:13:02.000Z

在本文档中,我将简述如何使用Let’s Encrypt来获得一个免费的SSL证书, 并且配置相应的Nginx，我们还将向您展示如何自动更新您的SSL证书。如果你运行一个不同的web服务器,只需遵循您的web服务器文档了解如何使用证书和你的设置。

  • Let’s Encrypt简介
  • 准备工作
  • 使用Standalone插件运行letsencrypt
  • 使用Webroot插件运行letsencrypt
  • 创建Let’s Encrypt配置文件
  • 创建自动更新脚本

Let’s Encrypt简介

Let’s Encrypt是一个新的证书颁发机构(CA),提供了一种简便的方法来获取和安装免费的TLS / SSL证书,从而使加密 的HTTPS在web服务器上。它通过提供一个软件客户端letsencrypt简化了过程,试图自动化大多数所需的步骤。目前,
Let’s Encrypt仍在开放测试,整个过程的获取和安装证书只在Apache web服务器是完全自动的。但是,我们仍然可以 可以通过手动安装的方式，无论你选择的是哪一个web服务器, 用Let’s Encrypt都可以很容易获得一个免费的SSL证书。

https://letsencrypt.org/

准备工作

在使用文档前，你必须要确认一下几点：

  • 拥有一台linux服务器，并且如果不是root用户必须具有sudo权限
  • linux服务器上安装了nginx和git
  • 拥有注册域名，因为加密是验证你的域名颁发证书，生成证书的时候会需要填写
  • 拥有一个邮箱，生成证书的时候会需要填写

使用Standalone插件运行letsencrypt

1. 安装Let’s Encrypt客户端

第一步安装Let’s Encrypt的客户端letsencrypt在你的服务器上，用来获取SSL证书。目前,最好的安装Let’s Encrypt客户端的方法就是从官方GitHub库克隆它。在以后,它可能会通过一个软件包管理器安装。

1
$ sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt

2. 获取一个证书

Let’s Encrypt提供了多种方式来获取SSL证书，通过各种插件。大多数的插件只会帮助你获得一个证书,你必须手动配置你的web服务器来使用。这些插件获取证书并且不需要安装,被称为“身份验证器”，因为它们只用于验证服务器是否应该颁发一个证书。下面将展示如何使用Standalone插件来获取SSL证书。

Standalone插件提供了一个非常简单的方法来获取SSL证书。它通过暂时运行一个小型的web服务器,在你服务器的80端口上,让我们的Let’s Encrypt CA可以连接并验证你的服务器，判断身份是否颁发证书。因此,这种方法要求80端口不能被占用。也就是说，在使用这个插件之前一定要停止你正常的web服务器（如果你的web服务器使用的端口是80(http)的话）。例如，如果你正在使用Nginx，你可以通过以下命令停止它：

1
$ sudo service nginx stop

如果你还是不确定的话，可以使用以下命令验证80端口是被占用

1
$ netstat -na | grep ':80.*LISTEN'

3. 运行Let’s Encrypt

在使用Let’s Encrypt之前，我们先进入到letsencrypt目录：

1
$ cd /opt/letsencrypt

现在通过以下命令使用Standalone插件运行:

1
$ ./letsencrypt-auto certonly --standalone

在letsencrypt初始化后，如果你是第一次获取证书，将需要填写一些信息。

填写一个邮件地址，用于通知和遗失钥匙的恢复

示例图
示例图

然后询问是否同意Let’s Encrypt的使用条款，选择同意

示例图
示例图

然后输入你的域名，如果想要一个证书适用于多个域名，那必须把所有的域名都填写上

示例图
示例图

如果一切顺利，你应该看到这样一个输出消息:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Output:
IMPORTANT NOTES:
 - If you lose your account credentials, you can recover through
   e-mails sent to sammy@digitalocean.com
 - Congratulations! Your certificate and chain have been saved at
   /etc/letsencrypt/live/example.com/fullchain.pem. Your
   cert will expire on 2016-03-15. To obtain a new version of the
   certificate in the future, simply run Let's Encrypt again.
 - Your account credentials have been saved in your Let's Encrypt
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Let's
   Encrypt so making regular backups of this folder is ideal.
 - If like Let's Encrypt, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

获得证书后，你将有以下PEM文件:

  • cert.pem: 你的域名证书
  • chain.pem: Let’s Encrypt的证书
  • fullchain.pem: cert.pem和chain.pem合并的证书
  • privkey.pem: 你的证书的私钥

你可以通过以下命令查看你的证书目录：

1
$ sudo ls /etc/letsencrypt/live/your_domain_name

4. 配置Web Server (Nginx)的TLS/SSL

现在你有一个SSL证书，你需要配置你的web服务器来使用它。下面将演示如何配置Nginx web服务器使用证书。如果你使用的是不同的web服务器，您需要参考相关如何设置SSL证书的文档。

1
$ sudo vi /etc/nginx/conf.d/nginx-example.conf

增加server配置，监听SSL的443端口，并且配置SSL证书。然后修改server监听的80端口重定向到https的443端口上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
server   {
   listen   80;
   server_name example.com;
   return 301 https://$host$request_uri;
}
 
server {
    listen   443 ssl;
    server_name example.com www.example.com;
    
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_prefer_server_ciphers on;   
    ssl_ciphers 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
}

配置好Nginx的SSL后保存退出，然后重启Nginx。之后就可以访问站点测试一下HTTPS是不是已经开始工作了

1
$ sudo service nginx restart

使用Webroot插件运行letsencrypt

现在，我们将使用Webroot插件运行letsencrypt，相比使用Standalone插件，它不需要停止你的web服务器，它可以通过你的web服务器来验证你的域名。Webroot插件添加一个隐藏的文件到你的web服务器的文档根目录,让加密的CA可以读取并且验证你的域名。

Webroot插件通过放置一个特殊的文件/.well-known在你的文档根目录，使得Let’s Encrypt可以通过web服务器验证加密服务。所以你需要显式的允许/.well-known的访问，确保能够正常的加密验证。所以让我们迅速改变一下Nginx的配置。

1
$ sudo vi /etc/nginx/conf.d/nginx-example.conf

编辑Nginx关于SSL的server配置，增加以下代码：

1
2
3
location ~ /.well-known {
    allow all;
}

修改玩Nginx配置后需要重新加载

1
$ sudo service nginx reload

使用Webroot插件，你必须要知道你的web服务器文档的根目录，你如果不清楚可以去查找相关的配置。在Nginx下，如果你没有修改过的话，文档的根目录地址是/usr/share/nginx/html。现在我们知道了web服务器的文档根目录(webroot-path)，我们就可以通过以下面命令来使用Webroot插件生成我们的证书，在这里，我们使用- d指定域名。

1
2
$ cd /opt/letsencrypt
$ ./letsencrypt-auto certonly -a webroot --agree-tos --renew-by-default --webroot-path=/usr/share/nginx/html -d example.com -d www.example.com

成功后，你将需要重新加载Nginx服务来使用新的证书:

1
$ sudo service nginx reload

创建Let’s Encrypt配置文件

上面文档中，我们通过Webroot插件来生成我们的证书，现在让我们简化一下更新过程，我们创建一个加密配置文件/usr/local/etc/le-renew-webroot.ini。

1
$ sudo cp /opt/letsencrypt/examples/cli.ini /usr/local/etc/le-renew-webroot.ini

现在我们打开并且编辑这个配置文件：

1
$ sudo vi /usr/local/etc/le-renew-webroot.ini

接下来，取消email, domains和webroot-path的注释，用你自己的信息去更新。完成后大概是这样的：

1
2
3
4
5
6
7
rsa-key-size = 4096

email = you@example.com

domains = example.com, www.example.com

webroot-path = /usr/share/nginx/html

现在，我们不需要指定webroot-path的路径和-d域名的信息了，我们可以指向加密配置文件来完成证书的更新。假设你的配置文件是正确的，下面的命令将更新我们的证书:

1
2
$ cd /opt/letsencrypt
$ ./letsencrypt-auto certonly -a webroot --renew-by-default --config /usr/local/etc/le-renew-webroot.ini

重新加载Nginx服务来验证一下吧:

1
$ sudo service nginx reload

创建自动更新脚本

使用Let’s Encrypt获取的加密证书有效期为90天，也就是说我们不得不在证书快到期的时候来手动更新一下证书。这样的工作是繁琐的，并且容易遗忘。所以，我们试想一下，我们已经简化了很多更新证书的工作，接下来我们是不是可以通过一个自动化脚本来完成这重复的劳动工作呢。答案是肯定的，在linux服务器上，我们可以通过cron job来设置自动更新脚本的运行周期，我们把这个运行周期设置为当检查到证书有效期不足30天时，我们每周去执行及脚本更新一下证书。我们这样设置可以确保我们的证书在过期之前即使有一个cron job失败了，我们仍有30天的时间可以让我们每周再试一次。

首先，我们下载一个自动更新脚本，并且设置为可执行

1
2
$ sudo curl -L -o /usr/local/sbin/le-renew-webroot https://gist.githubusercontent.com/thisismitch/e1b603165523df66d5cc/raw/fbffbf358e96110d5566f13677d9bd5f4f65794c/le-renew-webroot
$ sudo chmod +x /usr/local/sbin/le-renew-webroot

备注：如果你的服务器是Redhat，那么请将文件放到/sbin目录下，例如：

1
2
$ sudo curl -L -o /sbin/le-renew-webroot https://gist.githubusercontent.com/thisismitch/e1b603165523df66d5cc/raw/fbffbf358e96110d5566f13677d9bd5f4f65794c/le-renew-webroot
$ sudo chmod +x /sbin/le-renew-webroot

注意：如果/usr/local/etc/le-renew-webroot.ini配置不存在，这个脚本将不会运行。另外，确保在配置文件中指定的第一个域名和你最初创建证书的时候指定的域名是相同的。

现在，如果你运行这个脚本，你将能够看到当前的证书还有多少天到期：

1
$ sudo le-renew-webroot
1
2
3
output
Checking expiration date for example.com...
The certificate is up to date, no need for renewal (89 days left).

接下来，我们将编辑crontab来创建一个新作业，并且将每周运行这个命令。

1
$ sudo crontab -e

添加下面一行代码：

1
30 2 * * 1 /usr/local/sbin/le-renew-webroot >> /var/log/le-renewal.log

保存并退出，这将创建一个新的cron作业，我们设定为每周一凌晨2点30分执行le-renew-webroot命令。命令产生的输出将被写入/var/log/le-renewal.log日志中。

]]> <!-- build time:Fri May 07 2021 18:19:42 GMT+0800 (GMT+08:00) --><hr><p>在本文档中,我将简述如何使用Let’s Encrypt来获得一个免费的SSL证书, 并且配置相应的Nginx，我们还将向您展示如何自动更 本地运行Cogitr API项目文档(Run locally Cogitr API documents) https://www.mingyugu.com/cogitr-local-run-settings.html 2016-02-16T01:44:11.000Z 2016-02-16T01:44:11.000Z
]]> 此文章已经加密，需要解密后才能阅读</br> 云翎科技项目文档 https://www.mingyugu.com/airwingtech-doc.html 2015-12-18T04:19:56.000Z 2015-12-18T04:19:56.000Z
]]> 此文章已经加密，需要解密后才能阅读</br>