服务注册和配置中心Nacos

1 Nacos简介

1.1 为什么叫Nacos？

• 前四个字母为Naming和Configuration的前两个字母，最后的s为Service。

1.2 Nacos是什么？

• 是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
• Nacos：Dynamic Naming and Configuration Service。
• Nacos就是注册中心和配置中心的结合，换言之Nacos=Eureka+Config+Bus。

1.3 Nacos能干嘛？

• 替代Eureka做服务注册中心。
• 替代Config做服务配置中心。

1.4 去哪里下？

• GitHub上的地址。
• 官网地址。

1.5 各种注册中心比较

服务注册和发现	CAP模型	控制台管理	社区活跃度
Eureka	AP	支持	低（2.x版本闭源）
Zookeeper	CP	不支持	中
Consul	CP	支持	高
Nacos	AP	支持	高

据说Nacos在阿里内部有超过10万的实例运行，已经过了类似双十一等各种大型流量的考研。

2 安装和运行

2.1 安装

2.1.1 准备工作

• 本地安装有JDK8和Maven3.x环境。

2.1.2 下载

• 下载地址。

2.2 运行

• 解压缩安装包。

• 直接在bin目录下，使用startup.cmd -m standalone命令启动Nacos。

• 命令运行成功后直接访问http://localhost:8848/nacos（默认用户名和密码为nacos/nacos）。

• 登录成功，结果页面：

3 Nacos作为服务注册中心

3.1 基于Nacos的服务提供者

3.1.1 新建Module，并导入相关依赖

• 父工程pom：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

• 本模块pom修改部分：

<!--   Nacos     -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

• 本模块pom完整部分：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring_cloud_demo</artifactId>
        <groupId>org.sunxiaping</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud_alibaba_provider9013</artifactId>

    <dependencies>
        <!--   Nacos     -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
</project>

3.1.2 修改配置文件

• application.yml

server:
  port: 9013

spring:
  application:
    name: cloud-alibaba-provider
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # 配置Nacos的地址

management:
  endpoints:
    web:
      exposure:
        include: '*'

3.1.3 启动类

package com.sunxiaping.alibaba;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2020-10-11 10:54
 */
@SpringBootApplication
@EnableDiscoveryClient
public class CloudAlibabaProvider9013Application {
    public static void main(String[] args) {
        SpringApplication.run(CloudAlibabaProvider9013Application.class, args);
    }
}

3.1.4 业务逻辑

• PaymentController.java

package com.sunxiaping.alibaba.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2020-10-11 10:57
 */
@RestController
public class PaymentController {
    
    @Value("${server.port}")
    private String serverPort;


    @GetMapping(value = "/payment/{id}")
    public String payment(@PathVariable(value = "id") Integer id) {
        return "Nacos的注册中心的端口是：" + serverPort + ",id是：" + id;
    }
}

3.2 基于Nacos的服务消费者

3.2.1 新建Module，并导入相关依赖

• 父工程pom：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

• 修改部分：

<!--   Nacos     -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

• 完整部分：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring_cloud_demo</artifactId>
        <groupId>org.sunxiaping</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud_alibaba_provider9015</artifactId>
    <dependencies>
        <!--   Nacos     -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

</project>

3.2.2 修改配置文件

• application.yml

server:
  port: 9015

spring:
  application:
    name: cloud-alibaba-consumer
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # 配置Nacos的地址

management:
  endpoints:
    web:
      exposure:
        include: '*'

3.2.3 启动类

package com.sunxiaping.alibaba;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2020-10-11 11:34
 */
@SpringBootApplication
@EnableDiscoveryClient
public class CloudAlibabaConsumer9015Application {
    public static void main(String[] args) {
        SpringApplication.run(CloudAlibabaConsumer9015Application.class, args);
    }
}

3.2.4 业务逻辑

• SpringConfig.java

package com.sunxiaping.alibaba.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2020-10-11 11:35
 */
@Configuration
public class SpringConfig {

    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

• OrderController.java

package com.sunxiaping.alibaba.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2020-10-11 11:35
 */
@RestController
public class OrderController {

    @Autowired
    private RestTemplate restTemplate;


    @GetMapping(value = "/order/{id}")
    public String order(@PathVariable(value = "id") Integer id) {
        return restTemplate.getForObject("http://cloud-alibaba-provider" + "/payment/" + id, String.class);
    }

}

4 各种服务注册中心对比

4.1 Nacos生态图

4.2 Nacos服务发现实例模型

4.3 Nacos和其他注册中心特性对比

4.4 Nacos支持AP和CP模式的切换

4.4.1 概述

• 如果不需要存储服务级别的信息且服务实例是通过Nacos Client注册，并能够保持心跳上报，那么就可以选择AP模式。当前主流的服务如Spring Cloud和Dubbo服务，都适用于AP模式，AP模式为了服务的可用性而减弱了一致性，因此AP模式下只支持临时实例。
• 如果需要在服务级别编辑或者存储配置信息，那么CP是必须，K8s服务和DNS服务则使用于CP模式。CP模式下支持注册服务化实例，此时则是以Raft协议为集群运行模式，该模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。

4.4.2 模式切换

• Nacos集群默认支持的CAP原则中的AP原则，但是也可以支持CP原则，切换命令如下：

curl -X PUT '$NACOS_SERVER:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP'

• 同时微服务的bootstrap.properties需要配置如下选择指明注册为临时/永久实例（AP模式不支持数据一致性，所以只支持服务注册的临时实例，CP模式支持服务注册的永久实例）。

#false为永久实例，true表示临时实例开启，注册为临时实例
spring.cloud.nacos.discovery.ephemeral=false

5 Nacos作为服务配置中心的基础配置

5.1 新建Modele，并导入相关依赖

• 修改部分：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

• 完整部分：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring_cloud_demo</artifactId>
        <groupId>org.sunxiaping</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud_alibaba_config_server3377</artifactId>

    <dependencies>
        <!--nacos-config-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--nacos-discovery-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--web + actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

</project>

5.2 YML

• Nacos和Spring Cloud Config一样，在项目初始化的时候，要保证先从配置中心进行配置拉取，拉取配置之后，才能保证项目的正常启动。

• SpringBoot中配置文件的加载时存在优先级顺序的，bootstrap优先级高于application。

• 示例：

• bootstrap.yml

spring:
  application:
    name: service-proudct
  profiles:
    active: dev
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # 服务注册中心的地址
      config:
        server-addr: 127.0.0.1:8848 # 配置中心的地址
        file-extension: yml # 执行yaml格式的配置

management:
  endpoints:
    web:
      exposure:
        include: '*'

5.3 向Nacos中添加配置信息

• Nacos中的dataId的组成格式和Spring Cloud中的配置文件的匹配规则。

• 官方地址。

5.4 启动类

package com.sunxiaping;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
public class ProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class, args);
    }
}

5.5 业务逻辑

• Product.java

package com.sunxiaping.domain;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.io.Serializable;
import java.math.BigDecimal;

@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "tb_product")
public class Product implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "product_name")
    private String productName;

    @Column(name = "status")
    private Integer status;

    @Column(name = "price")
    private BigDecimal price;

    @Column(name = "product_desc")
    private String productDesc;

    @Column(name = "caption")
    private String caption;

    @Column(name = "inventory")
    private String inventory;

}

• ProductRepository.java

package com.sunxiaping.dao;


import com.sunxiaping.domain.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductRepository extends JpaRepository<Product, Long>, JpaSpecificationExecutor<Product> {

}

• ProductService.java

package com.sunxiaping.service;


import com.sunxiaping.domain.Product;

public interface ProductService {

    /**
     * 根据id查询
     *
     * @param id
     * @return
     */
    Product findById(Long id);


    /**
     * 保存
     *
     * @param product
     */
    void save(Product product);


    /**
     * 更新
     *
     * @param product
     */
    void update(Product product);


    /**
     * 删除
     *
     * @param id
     */
    void delete(Long id);


}

• ProductServiceImpl.java

package com.sunxiaping.service.impl;


import com.sunxiaping.dao.ProductRepository;
import com.sunxiaping.domain.Product;
import com.sunxiaping.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class ProductServiceImpl implements ProductService {

    @Autowired
    private ProductRepository productRepository;

    @Override
    public Product findById(Long id) {
        return this.productRepository.findById(id).orElse(new Product());
    }

    @Override
    public void save(Product product) {
        this.productRepository.save(product);
    }

    @Override
    public void update(Product product) {
        this.productRepository.save(product);
    }

    @Override
    public void delete(Long id) {
        this.productRepository.deleteById(id);
    }
}

• ProductController.java

package com.sunxiaping.controller;


import com.sunxiaping.domain.Product;
import com.sunxiaping.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping(value = "/product")
@RefreshScope //开启动态刷新
public class ProductController {

    @Value("${server.port}")
    private String port;

    @Value("${spring.cloud.client.ip-address}")
    private String ip;

    @Autowired
    private ProductService productService;

    @PostMapping(value = "/save")
    public String save(@RequestBody Product product) {
        this.productService.save(product);
        return "新增成功";
    }

    @GetMapping(value = "/findById/{id}")
    public Product findById(@PathVariable(value = "id") Long id) {
        Product product = this.productService.findById(id);
        product.setProductName("访问的地址是：" + this.ip + ":" + this.port);
        return product;
    }
}

6 Nacos作为服务配置中心的分类配置

6.1 问题：多项目多环境问题

6.1.1 问题1

• 在实际开发中，通常一个系统会准备：dev开发环境，test测试环境，prod生产环境。如何保证指定环境启动时服务能正确读取到Nacos上相应环境的配置文件？

6.1.2 问题2

• 一个大型分布式微服务会有很多微服务子项目，每个微服务服务又都会有相应的开发环境、测试环境、预发布环境、正式环境等等，如果对这些微服务配置进行管理？

6.2 Nacos图形化界面管理

6.2.1 配置列表

6.2.2 命名空间

6.3 Namespace+Group+DataId什么关系，为什么这么设计？

6.3.1 Namespace+Group+DataId是什么？

• Namespace+Group+DataId类似于Java里面的package（包名）和类名。
• 最外层的namespace是可以用于区分部署环境的，Group和DataId逻辑上区分两个目标对象。

6.3.2 Namespace+Group+DataId的关系以及设计的意图

• 默认情况下，Namespace=public、Group=DEFAULT_GROUP，默认Cluster是DEFAULT。
• Nacos的默认的命名空间是public，Namespace主要用来实现隔离。比如说，现在有三个环境：开发、测试和生产环境，我们就可以创建三个Namespace，不同的Namespace之间是隔离的。
• Group默认是DEFAULT_GROUP，Group可以把不同的微服务划分到同一个分组里面。
• Service就是微服务。一个Service可以包含多个Cluster（集群），Nacos默认Cluster就是DEFAULT，Cluster是对指定微服务的一个虚拟划分。比如说，为了容灾，将Service微服务分别部署在了杭州机房和广州机房，这时候就可以给杭州机房的Service微服务起一个集群名称（HZ），给广州机房的Service微服务起一个集群名称（GZ），还可以尽量让同一个机房的微服务互相调用，以提升性能。
• Instance，就是微服务的实例。

7 Nacos集群和持久化配置

7.1 官网说明

7.1.1 官网地址

• 官网地址。

7.1.2 官网集群架构图

7.1.3 Nacos集群架构图理解

7.1.4 说明

• Nacos支持的三种部署模式。

7.2 单机版的Nacos持久化配置

• Nacos默认自带的是嵌入式数据库derby，不方便观察数据存储的基本情况，需要将数据源由derby切换到MySQL。

• derby切换到MySQL的步骤：

• 1️⃣安装MySQL数据库，版本要求5.6.5+。

• 2️⃣初始化MySQL数据库，数据库的sql脚本在nacos/conf/nacos-mysql.sql文件中：

• 3️⃣修改conf/application.properites文件，增加支持MySQL数据源配置（目前只支持MySQL），添加MySQL的数据源的URL、用户和密码等。

spring.datasource.platform=mysql

db.num=1
db.url.0=jdbc:mysql://localhost:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=123456

7.3 Linux版Nacos+MySQL生产环境配置

7.3.1 准备工作

• Nginx：1个。
• Nacos Server：3个。
• MySQL：1个（IP地址为192.168.32.100，端口是3306）。
• Centos7：3个（IP地址分别为192.168.32.100、192.168.32.101和192.168.32.102）。

7.3.2 逻辑架构图

7.3.3 在每个Centos7系统中下载Linux版本的Nacos

cd /opt
wget https://github.91chifun.workers.dev//https://github.com/alibaba/nacos/releases/download/1.3.2/nacos-server-1.3.2.tar.gz
tar -zxvf nacos-server-1.3.2.tar.gz

7.3.4 将nacos-mysql.sql文件导入到MySQL数据库中

7.3.4 持久化配置

• 在每个CentOS7系统上的Nacos的conf/application.properties文件中加入如下的配置：

# 在最后一行添加
spring.datasource.platform=mysql

db.num=1
db.url.0=jdbc:mysql://192.168.32.100:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=123456

7.3.5 集群配置

• 在每个CentOS7系统上的Nacos的conf目录，复制cluster.conf.example文件，并改名为cluster.conf：

cp cluster.conf.example cluster.conf

• 修改每个CentOS7系统上的Nacos的conf/cluster.conf文件，并添加如下的配置：

192.168.32.100:8848
192.168.32.101:8848
192.168.32.102:8848

• 分别启动各个Nacos服务。

/opt/nacos/bin
./startup.sh

7.3.6 修改Nginx的配置文件并启动Nginx

• nginx.conf

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;
    # -----------修改-----------------    
    upstream nacos {
        server 192.168.32.100:8848;

        server 192.168.32.101:8848;

        server 192.168.32.103:8848;
    }
    # -----------修改-----------------    
    server {
        # -----------修改-----------------    
        listen       8089;
        # -----------修改-----------------    
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }
        # -----------修改-----------------    
        location ^~ /nacos{
            proxy_pass http://nacos;

            # nginx非80端口处理

            proxy_set_header        Host $host:$server_port;

            # 获取真实IP

            proxy_set_header        X-Real-IP $remote_addr;

            # 获取代理者的真实ip

            proxy_set_header       X-Forwarded-For        $proxy_add_x_forwarded_for;

            # 解决getScheme，isSecure，sendRedirect

            proxy_set_header X-Forwarded-Scheme  $scheme;

            client_max_body_size    1000m;

            client_body_buffer_size 128k;

            proxy_connect_timeout   90;

            proxy_send_timeout      90;

            proxy_read_timeout      90;

            proxy_buffer_size       4k;

            proxy_buffers           4 32k;

            proxy_busy_buffers_size 64k;

            proxy_temp_file_write_size 64k;

        }
        # -----------修改-----------------    
        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}