Los siguientes temas se estudiarán a continuación:
- El papel de los nacos: ¿cómo funciona nacos ?, ¿qué papel juega nacos en el cluster?
- Modificar la base de datos de configuración de nacos: La información que configuramos en la consola se escribe en la base de datos predeterminada de nacos por defecto, lo cual no es conveniente para la gestión, por lo que configuramos nuestra propia base de datos para las operaciones de gestión.
- Configurar la configuración de nacos en la consola
- Modelo de gestión de la configuración de Nacos: conceptos básicos, espacio de nombres, grupo, id de datos y su uso
- Gestión del espacio de nombres, uso del espacio de nombres
- Gestión de configuración Nacos aplicada a sistemas distribuidos
-
7.Despliegue del clúster Nacos
1. El papel de los nacos
Esta imagen muestra que nacos es un servidor independiente. Si los usuarios modifican o publican información de configuración, notificarán a los servidores descendentes. Los servidores descendentes también pueden leer la información de configuración del centro de configuración de acuerdo con ciertas reglas.
Haga que los nacos formen parte del grupo de nubes de primavera
-
Iniciar el servicio nacos
-
Incluir nacos como parte de los microservicios de Spring Cloud
- Registre otros servicios de aplicaciones de Spring Cloud en nacos.
2. Modificar la base de datos de configuración de nacos
A continuación para verificar la disponibilidad del servicio
1. Inicie nacos
./startup.sh -m independiente
Nota: El modo autónomo debe iniciarse aquí, el modo predeterminado es el modo de clúster, ahora no estamos en el clúster y se informará una excepción.
2 Publicar la configuración en el centro de configuración
Nacos es un servicio, también proporciona muchas interfaces externas, una de las cuales es agregar interfaz de configuración. Simulamos esta interfaz para la configuración:
curl -X POST " http: // localhost: 8848 / nacos / v1 / cs / configs? dataId = nacos.cfg.dataId & group = test & content = HelloWorld "
Verifique que el resultado devuelto sea verdadero. Luego actualice la consola, puede ver lo siguiente
3. Obtenga la configuración del centro de configuración
curl -X GET " http: // localhost: 8848 / nacos / v1 / cs / configs? dataId = nacos.cfg.dataId & group = test "
Este comando es para obtener la configuración
Obtener contenido de helloworld
4. Cambiar la ubicación de almacenamiento de los datos de configuración de nacos
Agregamos la información de configuración a nacos, entonces, ¿cómo la guarda? Nacos tiene una base de datos incorporada predeterminada, que no es conveniente para operar y encontrar. Así que la reemplazamos con nuestra propia base de datos mysql
1. Prepare una base de datos mysql
Debido a que mysql es relativamente grande, utilizo docker instalado mysql
Descarga mysql
docker extraer mysql: 5.7.15
Iniciar mysql
docker run -p 3306: 3306 --name MySQLDocker -v $ PWD / conf / my.cnf: /etc/mysql/conf.d/my.cnf -v $ PWD / logs: / var / log / mysql -v $ PWD / datos: / var / lib / mysql -e MYSQL_ROOT_PASSWORD = 123456 -d mysql: 5.7.15
2. Cree una base de datos nacos_config
3. Inicialice la estructura de la tabla nacos_config
Encuentre el archivo de configuración aquí: $ (nacosHome) / conf / nacos-mysql.
4. Modifique el archivo de configuración application.properties
y reinicie.
Realice la configuración de escritura anterior
Se genera una pieza de información de configuración en la base de datos:
Configuración de tres nacos
1. Agregar configuración en la consola
Data ID: nacos-simple-demo.yaml
Group: DEFAULT_GROUP
配置格式: YAML
配置内容:
common
config: somethingConfigure la información anterior en la consola. Lo 
anterior es para construir la información de configuración en el servidor nacos.
2. Simular la configuración del servidor nacos para obtener cliente nacos
public class DemoTest {
public static void main(String[] args) throws NacosException {
String dataId = "test.demo.yml";
String group = "DEFAULT_GROUP";
String serverAddr = "localhost:8848";
Properties properties = new Properties();
properties.setProperty("serverAddr", serverAddr);
// 和nacos服务建立连接
ConfigService configService = NacosFactory.createConfigService(properties);
String config = configService.getConfig(dataId, group, 10);
System.out.println(config);
}
}ok, puedes obtener la información de configuración de nacos
Cuatro. Modelo de gestión de la configuración de Nacos
Para la administración de la configuración de nacos, un conjunto de configuración se puede ubicar a través del espacio de nombres, grupo y dataId.
El modelo de gestión de la configuración de nacos consta de tres partes: espacio de nombres, grupo, id de servicio / datos. A través del modelo de gestión de la configuración, podemos localizar el archivo de configuración requerido
Entre ellos, service / data Id. Server es el descubrimiento de servicios, dataId es la gestión de la configuración.
1. Conjunto de configuración (DataId)
El conjunto de configuración es el DataId en la figura anterior
En el sistema, generalmente un archivo de configuración es un conjunto de configuración. Un conjunto de configuración puede contener diversa información de configuración del sistema. Por ejemplo, un conjunto de configuración puede contener información de configuración de la fuente de datos del sistema, el grupo de conexiones y el nivel de registro. Cada conjunto de configuración puede definir un nombre significativo, que es el Id del conjunto de configuración, es decir, Id de datos
2. Elementos de configuración
El contenido de la configuración incluido en el conjunto de configuración es el elemento de configuración. Representa el parámetro configurable específico. Normalmente existe en forma de clave = valor.
3. Configurar grupo (grupo)
La agrupación de configuración es el Grupo en la figura anterior. La agrupación de configuración es la agrupación de conjuntos de configuración. Está representada por una cadena significativa (como comprar, intercambiar). Diferentes grupos de configuración pueden tener el mismo conjunto de configuración (ID de datos) crea una configuración en nacos, si el nombre del grupo de configuración no se completa, se utilizará el nombre predeterminado DEFAULT_GROUP.
Los escenarios comunes para la agrupación de configuraciones son: Se puede utilizar para distinguir diferentes proyectos o aplicaciones Por ejemplo: El conjunto de configuración del sistema de gestión de estudiantes puede definir un grupo como: STUDENT_GROUP.
4 Espacio de nombres
El espacio de nombres (namespace) se puede utilizar para configurar el aislamiento para diferentes entornos. Por ejemplo: puede aislar el entorno de desarrollo, el entorno de prueba y el entorno de compilación. Debido a que su configuración puede ser diferente. O para aislar a diferentes usuarios, diferentes desarrolladores usan el mismo A nacos gestiona sus respectivas configuraciones, que pueden aislarse por espacio de nombres. En diferentes espacios de nombres, puede haber grupos de configuración o elementos de configuración (Data Id) con el mismo nombre
La mejor práctica
generalmente podemos definir espacio de nombres, grupo, id de datos de esta manera
-
Espacio de nombres: representa diferentes entornos, como: desarrollo, pruebas, producción, etc.
-
Grupo: puede representar un determinado proyecto, como XX proyecto médico, XX proyecto de comercio electrónico
- DataId: a menudo hay varios proyectos en cada proyecto, y cada conjunto de configuración (DataId) es el archivo de configuración principal de un proyecto
Analizar proyectos existentes
5. Gestión del espacio de nombres
Primero revisemos la implementación del cliente anterior. En la implementación del cliente anterior, no definimos un espacio de nombres. Luego, usará el espacio de nombres público predeterminado.
1. Diseño de aislamiento del espacio de nombres
-
Diseñe el espacio de nombres de acuerdo con el entorno:
la configuración de diferentes entornos, como el desarrollo, las pruebas y la producción, están aisladas entre sí y no se afectan entre sí.
- También se puede diseñar de manera multiusuario. Por ejemplo, Zhang San, Li Si, Wang Wu, ven que su propio contenido es diferente.
2. Gestión del espacio de nombres
Crear espacio de nombres
El funcionamiento de la interfaz es relativamente simple, sin mencionarlo.
A continuación, creé 4 espacios de nombres. Tanto el público como el desarrollador tienen un ID de datos llamado test.demo.yml. Quiero obtener el archivo de configuración test.demo.yml en dev a través del código del programa.
El cliente simulado obtiene la información de configuración en el espacio de nombres nacos como dev:
package com.lxl.org;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
import java.util.Properties;
public class DemoTest {
public static void main(String[] args) throws NacosException, InterruptedException {
String dataId = "test.demo.yml";
// 注意: 这里填的是命名空间的id
String namespace = "dev";
String group = "DEFAULT_GROUP";
String serverAddr = "localhost:8848";
Properties properties = new Properties();
properties.setProperty("serverAddr", serverAddr);
properties.setProperty("namespace", namespace);
// 和nacos服务建立连接
ConfigService configService = NacosFactory.createConfigService(properties);
String config = configService.getConfig(dataId, group, 10);
System.out.println(config);
Thread.sleep(1000);
}
}Debe especificar en qué espacio de nombres obtener la configuración.
3. Ver versión histórica
La versión histórica está aquí para hablar de ello, es decir, puede retroceder. Haga clic en retroceder y volverá a una determinada versión de la configuración.
4. Supervisar consulta
Si desea monitorear un determinado archivo de configuración en el entorno de desarrollo, puede verificar qué archivos de configuración se monitorean en la consulta de monitoreo.
Por ejemplo: escribimos una demostración y monitoreamos el archivo de configuración test.demo.yaml en dev
public static void main(String[] args) throws NacosException, InterruptedException {
String dataId = "test.demo.yml";
// 注意: 这里填的是命名空间的id
String namespace = "a127e7f7-e37e-48fb-9968-cca7ef7c9f26";
String group = "DEFAULT_GROUP";
String serverAddr = "localhost:8848";
Properties properties = new Properties();
properties.setProperty("serverAddr", serverAddr);
properties.setProperty("namespace", namespace);
// 和nacos服务建立连接
ConfigService configService = NacosFactory.createConfigService(properties);
String config = configService.getConfig(dataId, group, 10);
System.out.println(config);
configService.addListener(dataId, group, new Listener() {
@Override
public Executor getExecutor() {
return null;
}
@Override
public void receiveConfigInfo(String s) {
// 接收监听到的返回的配置信息
System.out.println(s);
}
});
Thread.sleep(1000000);
}Escriba un programa de escucha para seguir monitoreando. Una vez que haya un cambio de configuración, puede notificarlo inmediatamente.
5. Gestión de inicio de sesión
nacos admite la función de inicio de sesión simple, el nombre de usuario / contraseña predeterminado es: nacos / nacos.
Para modificar el nombre de usuario y la contraseña predeterminados:
Observando el código fuente podemos saber que la encriptación del usuario nacos utiliza el método de encriptación BCrypt, por lo que podemos simular un método BCrypt para modificar la contraseña
- Introducir el paquete jar de BCrypt en el proyecto
<dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-core</artifactId> <version>5.1.4.RELEASE</version> </dependency>
然后写一个修改密码的方法paquete com.lxl.org;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
Public class PasswordHandler {
public static void main (String [] args) {
String encode = new BCryptPasswordEncoder (). encode ("123");
System.out.println (codificar);
}
}
输出结果替换数据库中的密码即可$ 2a $ 10 $ LW / 6RKgceuALErDPcU8THOT5V1Ajc98jgo6N38oOX0Tvmce39hP4a
新加用户, 需要设置用户的用户名和角色insertar en los usuarios (nombre de usuario, contraseña, habilitado) VALUES ("lxl", "$ 2a $ 10 $ LW / 6RKgceuALErDPcU8THOT5V1Ajc98jgo6N38oOX0Tvmce39hP4a", 1);
insertar en roles (nombre de usuario, rol) VALORES ('lxl', 'ROLE_ADMIN')
也可以在控制台修改
### **六. Nacos配置管理应用于分布式系统**
下图展示了nacos集中管理多个配置服务的流程
1. 用户通过nacos 服务的控制台对配置文件进行集中管理
2. 各服务统一从nacos中获取各自的配置, 并监听配置的变化.
----------------------------------------
## 1. 模拟两个微服务请求一个注册中心的场景.
**1. 在dev环境下, 新建两个配置文件. server1, server2**
**2. 创建一个简单的微服务架构. 采用spring cloud微服务架构.**
创建一个parent工程, 引入公共的配置. 在创建两个微服务server1, server2
创建一个parent maven工程, 引入maven包<dependencyManagement>
<dependencies>
<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>
<dependency>
<groupId> org.springframework.cloud </groupId>
<artifactId> spring-cloud-dependencies </artifactId>
<version> Greenwich.RELEASE </version>
<type> pom </type>
<scope> import </scope>
</dependency>
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> Spring-boot-dependencies </artifactId>
<version> 2.1.3.RELEASE </version>
<type> pom </type>
<scope> importar </scope>
</dependency>
</dependencies>
</dependencyManagement>
创建一个service1. 然后添加nacos的maven管理. 在添加bootstrap.yml配置文件, 最后增加启动类<dependencies>
<dependency>
<groupId> com.alibaba.cloud </groupId>
<artifactId> spring-cloud-starter-alibaba-nacos-config </artifactId>
</dependency>
<dependency>
<groupId> org.springframework. boot </groupId>
<artifactId> spring-boot-starter-web </artifactId>
</dependency>
</dependencies>
配置文件bootstrap.yml. 这里需要注意的是默认查找的data Id是应用面+扩展名
servidor:
puerto: 56010
spring:
application:
name: service1
cloud:
nacos:
config:
server-addr: localhost: 8848
file-extension: yaml
namespace: dev
group: TEST_GROUP
Busque el ID de datos predeterminado -> nombre de la aplicación + extensión de archivo -> service1.yaml
最后增加启动类, 里面直接定义了一个controller, 获取配置信息
package com.lxl.www.service1;
importar org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
importar org.springframework.boot.autoconfigure.SpringBootApplication;
importar org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication br /> @ RestController
clase pública BootStrapApplication {
público vacío estático principal (String [] args) {
SpringApplication.run (BootStrapApplication.class, args);
}
/**
* 采用注解的方式读取nacos配置信息
*/
@Value("${common.config}")
private String config1;
/**
* 定义一个controller
*/
@GetMapping(value = "/config")
public String getNacosConfig() {
return config1;
}}
service2也是如此. Nota: Cuando se publique nacos, abra el archivo de registro para ver si la versión es exitosa. Si se informa una excepción, es posible que la versión no sea exitosa. El proyecto no pudo obtener el archivo de configuración
**这里客户端使用的是阿里提供的nacos客户端:** spring-cloud-starter-alibaba-nacos-config
**存在的问题:**
当使用spring的注解@Value的时候, 我们发现, 在配置中心修改了配置文件的内容, 但是通过注解读取出来的内容没变. 这是什么愿意闹呢?其实, 配置文件修改了内容以后, 他是通知了服务端的, 之所以没改, 是因为@Value属性的原因, 他应该是有缓存了. 那么如果想动态获取修改后的配置文件, 有两种方式:
**方式一: 使用properties.**
获取配置的方式, 修改如下:
@Autowired
private ConfigurableApplicationContext applicationContext;
/**
* 定义一个controller
*/
@GetMapping(value = "/config")
public String getNacosConfig() {
return applicationContext.getEnvironment().getProperty("common.config");
} **方式二: @NacosValue**
注意事项:
- nacos的配置信息要写在bootstrap.yml中. 让其配置信息优先加载. (bootstrap.yml加载的时间要比application.yml早)
## **2. 扩展DataId, 多配置处理**
如果有多个配置文件, 我们可以使用扩展配置的方式, 添加多个配置文件
ID de configuración extendida, el primer identificador de configuración extendido
ext-config [0]:
data-id: ext-config-common01.yml
ext-config [1]:
id-datos: ext-config-common02.yml
grupo: GLOBAL_GROUP
ext-config [2]:
data-id: ext-config-common03.yml
group: REFRESH_GROUP
refresh: true # Modificación de la configuración , si se debe actualizar
第一个配置, 只有一个data-id. 没有group, 采用默认的DEFAULT_GROUP.
第二个扩展配置. 定义了一个GLOBAL_GROUP. 全局配置
第三个扩展配置: 定义为一个自动刷新的GROUP, 并设置自动刷新属性为true
接下来我们在控制台添加这三个文件
修改接口获取配置信息
/**
* 定义一个controller
*/
@GetMapping(value = "/config")
public String getNacosConfig() {
String p1 = applicationContext.getEnvironment().getProperty("common.config");
String p2 = applicationContext.getEnvironment().getProperty("common.ext1");
String p3 = applicationContext.getEnvironment().getProperty("common.ext2");
String p4 = applicationContext.getEnvironment().getProperty("common.ext3");
return p1 + "+" + p2 + "+" + p3 + "+" + p4;
}
我们可以看到打印出来的效果
这时, 在控制台修改配置文件, 我们发现common.config会改变. common.ext3会改变. 其他两个不会自动更新
总结: 默认配置是可以自动刷新的. 在扩展配置中, 只有增加了属性refresh:true, 才会自动刷新
## 3. 共享Data Id
我们可以设置共享data id, 设置方法如下:
设置共享的data id. 我们设置了三个文件. 启动项目, 运行结果如下
我们发现, 有两个是null. 为什么是null呢? 因为使用这种方式配置, 只能第一个文件生效, 因此, 如果想要配置多个扩展文件, 还要使用扩展dataId的方式.
## **4. 配置Data Id的优先级**
**目前有三种设置Data Id的方式**
- 默认的data id. 项目名+扩展名的方式.
- 使用ext-config[0] 设置扩展配置
- 使用shared-dataids: 设置共享配置.
那么, 他们三个的优先级是什么样的呢?
**默认配置 > ext-config > shared-dataids**
如果有多个ext-config扩展配置, 谁的优先级高呢? n的个数越大, 优先级越高.....
**ext-config[n] > ext-config[2] > ext-config[1] > ext-config[0]**
## 5. 关闭Nacos配置
如果不想要使用nacos配置了, 那么可以使之enable属性为false
# 七. Nacos集群部署
通常我们在生成环境不可能只有一台nacos. 为了保证高可用性, 我们会配置多台nacos.
要求: 配置3台或以上nacos服务
下面我们来模拟三台nacos服务集群
第一步: 解压三个nacos服务
第二步: 修改配置文件
1. 修改端口号. 分别设置为8848, 8849, 8850
**2. 添加本地服务的ip地址**
给三个服务都增加下面这个配置内容: 设置本机的ip地址
>nacos.inetutils.ip-address=127.0.0.1
**3. 设置三个nacos的集群关系**
修改cluster.conf.example文件为cluster.conf
并在里面添加如下内容
**第四步: 启动三台服务器. 以集群的模式启动**
./start.sh -m cluster
然后, 在控制他查看集群, 有一台主, 两台从
**第五步 在项目中配置nacos集群**
注意: 多个配置之间不能带空格.
重启项目. 访问接口返回内容
这里面, 我们可以停掉任何一台nacos服务. 只要还有一个能运行, 服务就可以访问通