Linux--6 redis订阅发布、持久化、集群cluster、nginx入门

一、redis发布订阅

　　Redis 通过 PUBLISH 、SUBSCRIBE 等命令实现了订阅与发布模式。

　　其实从Pub/Sub的机制来看，它更像是一个广播系统，多个Subscriber可以订阅多个Channel，多个Publisher可以往多个Channel中发布消息。可以这么简单的理解：

　　　　- Subscriber：收音机，可以收到多个频道，并以队列方式显示；

　　　　- Publisher：电台，可以往不同的FM频道中发消息；

　　　　- Channel：不同频率的FM频道；

　　一个Publisher，多个Subscriber模型：如下图所示，可以作为消息队列或者消息管道

　　主要应用：通知、公告

1、发布/订阅的命令

PUBLISH channel msg
将信息 message 发送到指定的频道 channel

SUBSCRIBE channel [channel ...]
订阅频道，可以同时订阅多个频道

UNSUBSCRIBE [channel ...]
取消订阅指定的频道, 如果不指定频道，则会取消订阅所有频道

PSUBSCRIBE pattern [pattern ...]
订阅一个或多个符合给定模式的频道，每个模式以 * 作为匹配符，比如 it* 匹配所有以 it 开头的频道( it.news 、it.blog 、it.tweets 等等)，news.* 匹配所有以news. 开头的频道( news.it 、 news.global.today 等等)，诸如此类

PUNSUBSCRIBE [pattern [pattern ...]]
退订指定的规则, 如果没有参数则会退订所有规则

PUBSUB subcommand [argument [argument ...]]
查看订阅与发布系统状态

注意：使用发布订阅模式实现的消息队列，当有客户端订阅channel后只能收到后续发布到该频道的消息，之前发送的不会缓存，必须Provider和Consumer同时在线。

View Code

2、发布/订阅演示

　　准备工作：启动三个redis-cli窗口，其中窗口1是发布者，窗口2、3是订阅者，订阅者都订阅music频道（channel）。

 3、订阅一个或者多个符合模式的频道

二、redis持久化（RDB与AOF）

　　Redis是一种内存型数据库，一旦服务器进程推出，数据库的数据就会丢失，为了解决这个问题，Redis提供了两种持久化的方案，将内存中的数据保存到磁盘中，避免数据的丢失。

1、RDB持久化

　　redis提供了RDB持久化的功能，这个功能可以将redis在内存中的状态保存到硬盘中，在指定的时间间隔间隔内生成数据集的时间点快照（point-in-time snapshot），它可以手动执行，也可以在redis.conf中配置，定期执行。

　　RDB持久化产生的RDB文件是一个经过压缩的二进制文件，这个文件被保存在硬盘中，redis可以通过这个文件还原数据库当时的状态。

　　第一步：准备一个配置文件，如rdb-redis.conf，写入下面代码

   [root@localhost redis-4.0.10]# touch rdb-redis.conf           创建配置文件 
　　[root@localhost redis-4.0.10]# vi rdb-redis.conf              编辑自己的配置文件
　　daemonize yes                             # 设置后台服务，非持久化必须
　　port 6379                                 # 设置端口号，非持久化必须
　　logfile /data/6379/redis.log              # redis日志文件
　　dir /data/6379                            # 定义持久化文件存储位置
　　dbfilename mydata.rdb                     # 定义rdb持久化文件名
　　# ########### 以下是定期持久化设置的rdb机制 ###################
　　save 900 1                               # 每900秒内   有1个修改记录则触发持久化
　　save 300 10                              # 每300秒内   有10个修改记录则触发持久化
　　save 60  10000                           # 每60秒内    有10000修改记录则触发持久化

　    第二步：启动redis服务端

1	[root@localhost redis - 4.0 . 10 ] # redis-server rdb-redis.conf

　　第三步：登录redis设置一个key

1 2 3

[root@localhost redis - 4.0 . 10 ] # redis-cli 127.0 . 0.1 : 6379 >  set  age  18          # 写入数据 OK

　　第四步：通过save命令触发持久化，将数据写入RDB文件

1 2	127.0 . 0.1 : 6379 > save                 # 手动通过save命令触发持久化 OK

　　第五步：此时检查/data/6379，有没有mydata.rdb文件

　　第六步：验证

　　　　重启redis服务端，重新登录redis查看数据

2、AOF持久化

　　AOF（append-only log file）记录服务器执行的所有变更操作命令（例如set del等），并在服务器启动时，通过重新执行这些命令来还原数据集

　　

AOF 文件中的命令全部以redis协议的格式保存，新命令追加到文件末尾。

　　优点：最大程序保证数据不丢；

　　缺点：日志记录非常大；

  　AOF持久化配置，有如下两个参数：
　　appendonly   yes
　　appendfsync  always      总是修改类的操作
              　　everysec   每秒做一次持久化
              　　no         依赖于系统自带的缓存大小机制

　　第一步：准备一个配置文件，如aof-redis.conf，写入如下代码

　　[root@localhost redis-4.0.10]# touch aof-redis.conf          创建配置文件 
　　[root@localhost redis-4.0.10]# vi aof-redis.conf              编辑自己的配置文件
　　daemonize yes                             # 设置后台服务，非持久化必须
　　port 6379                                 # 设置端口号，非持久化必须
　　logfile /data/6379/redis.log             # redis日志文件
　　dir /data/6379                            # 定义持久化文件存储位置
　　appendonly   yes                          # 使用aof持久化
　　appendfsync  everysec                    # 每秒做一次持久化

　　第二步：启动redis服务端

　　第三步：此时查看目录/data/6379，有没有文件appendonly.aof

1 2	[root@web02  6379 ] # ls appendonly.aof  redis.log

　　第四步：登录redis，写入数据，再开一个窗口实时检查aof文件信息

1	[root@web02  6379 ] # tail -f appendonly.aof             # 实时检查aof文件信息

　　第五步：验证

　　　　重启redis服务端，登录，查看数据是否存在　　

3、redis 持久化方式有哪些？有什么区别？

　　rdb：基于快照的持久化，速度更快，一般用作备份，主从复制也是依赖于rdb持久化功能。

　　aof：以追加的方式记录redis操作日志的文件，可以最大程度的保证redis数据安全，类似于mysql的binlog。

4、redis不重启，切换RDB到AOF

　　首先，要确保redis版本在2.2以上

1	[root@localhost ~] # redis-server -v                查看redis版本

　　准备阶段：

　　[root@localhost redis-4.0.10]# redis-server my-redis.conf   目前是rdb持久化模式
　　my-redis.conf文件内容如下：
　　daemonize yes                             
　　port 6379                                 
　　logfile /data/6379/redis.log             
　　dir /data/6379                            
　　dbfilename mydata.rdb                     
　　save 900 1                               
　　save 300 10                              
　　save 60  10000                     

　　切换RDB到AOF：

1 2 3 4

[root@localhost redis - 4.0 . 10 ] # redis-cli 127.0 . 0.1 : 6379 > CONFIG  set  appendonly yes                # 用命令激活aof持久化 OK 127.0 . 0.1 : 6379 > CONFIG  SET  save ""                         # 关闭rdb持久化

　　　　注意：此命令只是临时生效，写入到配置文件才能永久生效

　　备份rdb文件，保证数据安全：

1	[root@localhost  6379 ] # cp mydata.rdb  /opt/

　　测试aof数据持久化：

1 2 3

127.0 . 0.1 : 6379 >  set  title golang                    # 写入数据 OK [root@localhost  6379 ] # tail -f appendonly.aof    # 检测aof文件，验证aof是否生效

　　注意：虽然此时RDB已经正确切换AOF，但是还得修改配置文件my-redis.conf，不然重启后，通过config set的配置将丢失，修改配置文件my-redis.conf为如下内容：

daemonize yes                             
　　port 6379                                 
　　logfile /data/6379/redis.log             
　　dir /data/6379                            
　　# dbfilename mydata.rdb                     
　　# save 900 1                               
　　# save 300 10                              
　　# save 60  10000
　　appendonly yes             
　　appendfsync everysec

三、redis主从同步

　　Redis集群中的数据库复制是通过主从同步来实现的，主节点（Master）把数据分发给从节点（Slave），主从同步的好处在于高可用，Redis节点有冗余设计。

　　原理：

　　　　- 从服务器向主服务器发送 SYNC 命令。

　　　　- 接到 SYNC 命令的主服务器会调用BGSAVE 命令，创建一个 RDB 文件，并使用缓冲区记录接下来执行的所有写命令。

　　　　- 当主服务器执行完 BGSAVE 命令时，它会向从服务器发送 RDB 文件，而从服务器则会接收并载入这个文件。

　　　　- 主服务器将缓冲区储存的所有写命令发送给从服务器执行。

1、环境准备（准备三个redis配置文件，通过端口的区分，启动三个redis数据库实例）

[root@localhost redis-4.0.10]# vi redis-6380.conf        编辑配置文件，写入如下内容
　　port 6380
　　daemonize yes
　　pidfile /data/6380/redis.pid
　　loglevel notice
　　logfile "/data/6380/redis.log"
　　dbfilename dump.rdb
　　dir /data/6380

　　通过命令快速生成配置文件redis-6381.conf和redis-6382.conf

1 2	[root@localhost redis - 4.0 . 10 ] # sed "s/6380/6381/g" redis-6380.conf > redis-6381.conf [root@localhost redis - 4.0 . 10 ] # sed "s/6381/6382/g" redis-6381.conf > redis-6382.conf

　　在根目录下创建6380、6381、6382三个目录

1	[root@localhost ~] # mkdir -p /data/{6380,6381,6382}

　　启动三个redis实例，如下图：

　　此时，三个实例数据互不影响，测试如下：

2、关闭三个redis实例

　　方式一：根据服务名杀死进程，可以杀死所有有关redis-server

1	[root@localhost redis - 4.0 . 10 ] # pkill redis-server

　　方式二：根据进程号pid杀死进程

1	[root@localhost redis - 4.0 . 10 ] # pkill redis-server

3、配置主从同步（主从规划：主节点为6380，从节点为6381和6382）

　　为从节点6381指明主的地址

1	[root@localhost redis - 4.0 . 10 ] # echo "slaveof 127.0.0.1 6380" >> redis-6381.conf

　　为从节点6382指明主的地址

1	[root@localhost redis - 4.0 . 10 ] # echo "slaveof 127.0.0.1 6380" >> redis-6382.conf

4、再次启动三个redis实例服务，查看redis主从同步方案

　　方式一：redis-cli登录后通过如下命令查看

1 2 3

127.0 . 0.1 : 6380 > info replication                 127.0 . 0.1 : 6381 > info replication 127.0 . 0.1 : 6382 > info replication

　　方式二：redis-cli登录前通过如下命令查看

1 2 3

[root@localhost redis - 4.0 . 10 ] # redis-cli -p 6380 info 或者 [root@localhost redis - 4.0 . 10 ] # redis-cli -p 6380 info Replication

5、测试，主库写入数据，检查从库数据

1 2 3 4

127.0 . 0.1 : 6380 >  set  year  2019              主库写入数据 OK 127.0 . 0.1 : 6381 > get year                  从库获取数据 "2019"

6、手动进行主从复制故障切换

　　1）杀死主库6380的实例进程

1	[root@localhost redis - 4.0 . 10 ] # kill -9 主库pid

　　2）手动切换主从身份，从两个从库中挑选一个作为新的主库，假设选6381为新的主库

1 2 3 4 5

[root@localhost redis - 4.0 . 10 ] # redis-cli -p 6381 127.0 . 0.1 : 6381 > slaveof no one            关闭 6381 原来从库的身份 [root@localhost redis - 4.0 . 10 ] # redis-cli -p 6382 127.0 . 0.1 : 6382 > slaveof no one 127.0 . 0.1 : 6381 > slaveof  127.0 . 0.1  6381

　　3）检查6381，6382的主从信息

四、redis哨兵

1、Redis-Sentinel

　　Redis-Sentinel是redis官方推荐的高可用性解决方案，当用redis作master-slave的高可用时，如果master本身宕机，redis本身或者客户端都没有实现主从切换的功能。而redis-sentinel就是一个独立运行的进程，用于监控多个master-slave集群，自动发现master宕机，进行自动切换slave > master。

　　Sentinel（哨兵、岗哨）主要功能如下：

　　　　- 不时的监控redis是否良好运行，如果节点不可达就会对节点进行下线标识；

　　　　- 如果被标识的是主节点，sentinel就会和其他的sentinel节点“协商”，如果其他节点也认为主节点不可达，就会选举一个sentinel节点来完成自动故障转义；

　　　　- 在master-slave进行切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换；

　　简而言之，Redis哨兵就是保护redis主从集群正常运转，当主库挂掉之后，自动地在从库中挑选新的主库，进行同步。

2、主从复制背景问题

　　Redis主从复制可将主节点数据同步给从节点，从节点此时有两个作用：

　　　　一旦主节点宕机，从节点作为主节点的备份可以随时顶上来。

　　　　扩展主节点的读能力，分担主节点读压力。

　　但是问题是：一旦主节点宕机，从节点上位，那么需要人为修改所有应用方的主节点地址（改为新的master地址），还需要命令所有从节点复制新的主节点。

　　这个问题，redis-sentinel可以解决。

3、主从复制架构

4、Redis-Sentinel架构

　　Sentinel是redis的一个进程，但是不存储数据，只是监控redis。

　　Sentinel会通过命令连接向被监视的主从服务器发送“HELLO”信息，该消息包含Sentinel的IP、端口号、ID等内容，以此来向其他Sentinel宣告自己的存在。与此同时，Sentinel会通过订阅连接接收其他Sentinel的“HELLO”信息，以此来发现监视同一个主从服务器的其他Sentinel。

　　sentinel1通过发送HELLO信息来让sentinel2和sentinel3发现自己，其他两个sentinel也会进行类似的操作，如下图：

　　1）多个sentinel发现并确认master有问题；

　　2）选举出一个sentinel作为领导；

　　3）选出一个slave作为master；

　　4）通知其余slave成为新的master的slave；

　　5）通知客户端主从变化；

　　6）等待老的master复活成为新master的slave；

　　Sentinel也可以同时监控多个主从架构，如下图：

5、redis-sentinel（哨兵）的配置

　　第一步：准备三个redis数据库实例（三个配置文件，通过端口区分）

1 2 3

[root@localhost redis - 4.0 . 10 ] # redis-server redis-6380.conf [root@localhost redis - 4.0 . 10 ] # redis-server redis-6381.conf [root@localhost redis - 4.0 . 10 ] # redis-server redis-6382.conf

　　主从规划：主库6380，从库6381、6382

　　第二步：准备三个哨兵的配置文件redis-sentinel-26380.conf（也是通过端口区分）

　　[root@localhost redis-4.0.10]# vi redis-sentinel-26380.conf    编辑配置文件，内容如下
　　port 26380  
　　dir /var/redis/data/
　　logfile "26380.log"

　　# 当前Sentinel节点监控 127.0.0.1:6380 这个主节点
　　# 2代表判断主节点失败至少需要2个Sentinel节点同意
　　# s15master是主节点的别名
　　sentinel monitor s15master 127.0.0.1 6380 2

　　# 每个Sentinel节点都要定期用PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30s且没有回复，则判定不可达
　　sentinel down-after-milliseconds s15master 30000

　　sentinel parallel-syncs s15master 1

　　# 故障转移超时时间为180秒
　　sentinel failover-timeout s15master 180000
　　daemonize yes

　　三个配置文件内容仅仅是port（端口）参数不同，其他都一样，因此按照如下方式快速生成其他两个：

1 2	sed  "s/26380/26381/g"  redis - sentinel - 26380.conf  >  redis - sentinel - 26381.conf sed  "s/26380/26382/g"  redis - sentinel - 26380.conf  >  redis - sentinel - 26382.conf

　　第三步：启动三个哨兵

1 2 3

[root@localhost redis - 4.0 . 10 ] # redis-sentinel redis-sentinel-26380.conf [root@localhost redis - 4.0 . 10 ] # redis-sentinel redis-sentinel-26381.conf [root@localhost redis - 4.0 . 10 ] # redis-sentinel redis-sentinel-26382.conf

　　启动后查看哨兵配置文件是否发生改变，以redis-sentinel-26380.conf为例，变化如下图：

　　第四步：检查哨兵的通信状态

1	[root@localhost redis - 4.0 . 10 ] # redis-cli -p 26380  info sentinel

6、redis哨兵高可用故障实验

　　情况一：杀掉redis主节点的进程6380端口，观察从节点是否会进行新的master选举，进行切换

　　情况二：重新开启旧的“master”节点进程6380端口，查看此时它的身份

　　总结：哨兵也是通过更改redis的配置文件，来切换主从身份。

五、redis-cluster

　　为什么要用redis-cluster？

　　　　- 并发问题：redis官方声称可以达到 10万/每秒（每秒执行10万条命令），假如业务需要每秒100万的命令执行呢？

　　　　- 数据量太大：一台服务器内存正常是16~256G，假如你的业务需要500G内存，你怎么办？配置一个超级牛逼的计算机，超大内存，超强cpu并不是一个好办法，正确的应该是考虑分布式，加机器，把数据分到不同的位置，分摊集中式的压力，一堆机器做一件事。

　　redis实例集群主要思想是将redis数据的key进行散列，通过hash函数特定的key会映射到指定的redis节点上。

1、数据分布理论　　

　　分布式数据库首要解决把整个数据集按照分区规则映射到多个节点的问题，即把数据集划分到多个节点上，每个节点负责整个数据的一个子集。

　　常见的分区规则有哈希分区和顺序分区。Redis-cluster采用哈希分区规则，因此接下来会讨论哈希分区规则：

　　　　- 节点取余分区；

　　　　- 一致性哈希分区；

　　　　- 虚拟槽分区(redis-cluster采用的方式)；

2、虚拟槽分区

　　Redis Cluster采用虚拟槽分区，虚拟槽分区巧妙地使用了哈希空间，使用分散度良好的哈希函数把所有的数据映射到一个固定范围内的整数集合，整数定义为槽（slot）。

　　Redis Cluster槽的范围是0 ～ 16383。

　　槽是集群内数据管理和迁移的基本单位。采用大范围的槽的主要目的是为了方便数据的拆分和集群的扩展，每个节点负责一定数量的槽。

3、搭建redis集群（redis cluster）

　　redis支持多实例的功能，我们在单机演示集群搭建，需要6个实例，三个是主节点，三个是从节点，数量为6个节点才能保证高可用的集群。

　　第一步：准备6个redis数据库实例，配置文件为redis-{7000...7005}.conf

[root@localhost redis-4.0.10]# mkdir myrediscluster      创建一个目录存放配置文件
　　[root@localhost myrediscluster]# vi redis-7000.conf      编辑配置文件，写入如下内容
　　port 7000
　　daemonize yes
　　dir "/opt/redis/data"
　　logfile "7000.log"
　　dbfilename "dump-7000.rdb"
　　cluster-enabled yes                      # 开启集群模式
　　cluster-config-file nodes-7000.conf　   　# 集群内部的配置文件
　　# redis cluster需要16384个slot都正常的时候才能对外提供服务，换句话说，只要任何一个slot异常那么整个cluster不对外提供服务，因此生产环境一般为no
　　cluster-require-full-coverage no

　　快速生成其他5个配置文件：

1 2 3 4 5

[root@localhost myrediscluster] # sed "s/7000/7001/g" redis-7000.conf > redis-7001.conf [root@localhost myrediscluster] # sed "s/7000/7002/g" redis-7000.conf > redis-7002.conf [root@localhost myrediscluster] # sed "s/7000/7003/g" redis-7000.conf > redis-7003.conf [root@localhost myrediscluster] # sed "s/7000/7004/g" redis-7000.conf > redis-7004.conf [root@localhost myrediscluster] # sed "s/7000/7005/g" redis-7000.conf > redis-7005.conf

　

　　第二步：启动这6个redis数据库实例

1 2 3 4 5 6

[root@localhost myrediscluster] # redis-server redis-7000.conf [root@localhost myrediscluster] # redis-server redis-7001.conf [root@localhost myrediscluster] # redis-server redis-7002.conf [root@localhost myrediscluster] # redis-server redis-7003.conf [root@localhost myrediscluster] # redis-server redis-7004.conf [root@localhost myrediscluster] # redis-server redis-7005.conf

　　第三步：配置ruby语言环境，脚本一键启动redis-cluster

　　　　1）下载ruby语言的源码包，解压缩

1 2	wget https: / / cache.ruby - lang.org / pub / ruby / 2.3 / ruby - 2.3 . 1.tar .gz tar  - zxvf ruby - 2.3 . 1.tar .gz

　　　　2）配置，编译且安装

1 2	. / configure  - - prefix = / opt / ruby /                   释放makefile make && make install                              编译且安装

　　　　查看ruby安装目录下的bin目录，有如下文件：

　　　

　　　　3）下载ruby操作redis的模块包

1	[root@localhost opt] # wget http://rubygems.org/downloads/redis-3.3.0.gem

　　　　4）配置ruby环境变量

　　[root@localhost ~]# echo $PATH
　　[root@localhost ~]# vim /etc/profile        编辑配置文件profile，写入下面一行代码
　　PATH=$PATH:/opt/ruby/bin/
　　[root@localhost ~]# source /etc/profile      读取文件，使配置生效

　　　　5）通过ruby的包管理工具gem去安装redis包，安装后会生成一个redis-trib.rb这个命令

1	gem install  - l redis - 3.3 . 0.gem

　　第三步：一键开启redis-cluster， 其实就是分配主从关系 以及 槽位分配 slot槽位分配

1	/ opt / redis - 4.0 . 10 / src / redis - trib.rb create  - - replicas  1  127.0 . 0.1 : 7000  127.0 . 0.1 : 7001 127.0 . 0.1 : 7002  127.0 . 0.1 : 7003  127.0 . 0.1 : 7004  127.0 . 0.1 : 7005

　　　　执行后如下图：

　　第四步：检查各节点主从状态

1 2 3 4 5 6

[root@localhost opt] # redis-cli -p 7000 info replication [root@localhost opt] # redis-cli -p 7001 info replication [root@localhost opt] # redis-cli -p 7002 info replication [root@localhost opt] # redis-cli -p 7003 info replication [root@localhost opt] # redis-cli -p 7004 info replication [root@localhost opt] # redis-cli -p 7005 info replication

　　第五步：向redis集群写入数据，查看数据流向

1 2	[root@localhost opt] # redis-cli -p 7000 -c            参数-c代表集群模式 127.0 . 0.1 : 7000 >  set  name tom                           写入数据

　　结果如下图：

　　总结：写入数据时会将key自动的重定向，放到某一个节点的slot槽位中。

六、nginx入门

1、web服务

　　我们大多数人都是通过访问网站而开始接触互联网的。我们平时访问的网站服务就是 Web 网络服务，一般是指允许用户通过浏览器访问到互联网中各种资源的服务。

　　Web 网络服务是一种被动访问的服务程序，即只有接收到互联网中其他主机发出的请求后才会响应，最终用于提供服务程序的 Web 服务器会通过 HTTP(超文本传输协议)或 HTTPS(安全超文本传输协议)把请求的内容传送给用户。

　　目前能够提供 Web 网络服务的程序有 IIS、Nginx 和 Apache 等。其中，IIS(Internet Information Services，互联网信息服务)是 Windows 系统中默认的 Web 服务程序。

　　2004 年 10 月 4 日，为俄罗斯知名门户站点而开发的 Web 服务程序 Nginx 横空出世。 Nginx 程序作为一款轻量级的网站服务软件，因其稳定性和丰富的功能而快速占领服务器市场，但 Nginx 最被认可的还是系统资源消耗低且并发能力强，因此得到了国内诸如新浪、网易、腾讯等门户站的青睐。

　　web服务器和web框架的关系：

　　web服务器（如nginx）- 接收HTTP请求（例如www.pythonav.cn/xiaocang.jpg）并返回数据；

　　web框架（如django、flask）- 开发web应用程序，处理接收到的数据；

2、nginx是什么

　　nginx是一个开源的，支持高性能，高并发的web服务和代理服务软件。它是一个俄罗斯人lgor sysoev开发的，作者将源代码开源出来供全球使用。

　　nginx比它大哥apache性能改进许多，nginx占用的系统资源更少，支持更高的并发连接，有更高的访问效率。

　　nginx不但是一个优秀的web服务软件，还可以作为反向代理，负载均衡，以及缓存服务使用。

　　它的安装也更为简单，方便，灵活。

　　Tengine是由淘宝网发起的Web服务器项目。它在Nginx的基础上，针对大访问量网站的需求，添加了很多高级功能和特性。Tengine的性能和稳定性已经在大型的网站如淘宝网，天猫商城等得到了很好的检验。它的最终目标是打造一个高效、稳定、安全、易用的Web平台。

　　我们通过如下命令查看网站的响应头信息，从而得知其使用的服务器：

3、安装环境准备

　　执行如下命令，yum解决编译nginx所需的依赖包，之后使用nginx就不会报错了

1	[root@localhost ~] # yum install gcc patch libffi-devel python-devel  zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel openssl openssl-devel -y

　　相关依赖包的解释如下：

- gcc ：安装 nginx 需要先将官网下载的源码进行编译，编译依赖 gcc 环境。
安装命令：yum install gcc-c++

- PCRE pcre-devel ：PCRE(Perl Compatible Regular Expressions) 是一个Perl库，包括 perl 兼容的正则表达式库。nginx 的 http 模块使用 pcre 来解析正则表达式，所以需要在 linux 上安装 pcre 库，pcre-devel 是使用 pcre 开发的一个二次开发库。nginx也需要此库。
安装命令：yum install -y pcre pcre-devel

- zlib ：zlib 库提供了很多种压缩和解压缩的方式，nginx 使用 zlib 对 http 包的内容进行 gzip ，所以需要在 Centos 上安装 zlib 库。
安装命令：yum install -y zlib zlib-devel

- OpenSSL ：OpenSSL 是一个强大的安全套接字层密码库，囊括主要的密码算法、常用的密钥和证书封装管理功能及 SSL 协议，并提供丰富的应用程序供测试或其它目的使用。nginx 不仅支持 http 协议，还支持 https（即在ssl协议上传输http），所以需要在 Centos 安装 OpenSSL 库。

4、安装nginx

　　第一步：下载压缩包

1	[root@localhost opt] # wget -c https://nginx.org/download/nginx-1.12.0.tar.gz

　　第二步：解压缩源码包

1	[root@localhost opt] # tar -zxvf nginx-1.12.0.tar.gz

　　第三步：配置、编译安装

1 2	[root@localhost nginx - 1.12 . 0 ] # ./configure --prefix=/opt/nginx112 [root@localhost nginx - 1.12 . 0 ] # make && make install

　　此时进入/opt/nginx112目录下，有如下目录：

　　第四步：启动nginx　　

1	[root@localhost sbin] # nginx

　　此时，已经成功启动nginx，使用浏览器即可访问，如下图：

1 2	[root@localhost sbin] # nginx -s stop                 # 关闭nginx [root@localhost sbin] # nginx -s reload               # 重启nginx

5、nginx的目录结构

1 2	[root@localhost nginx112] # ls conf  html  logs  sbin

　　conf 存放nginx所有配置文件的目录，主要nginx.conf；
　　html 存放nginx默认站点的目录，如index.html 、error.html等；
　　logs 存放nginx默认日志的目录，如error.log 、access.log；
　　sbin 存放nginx主命令的目录，sbin/nginx；

 

 

 

 

 

 

转载于:https://www.cnblogs.com/wxj1129549016/p/10208970.html