(Obsoleto) Desplegar un clúster Milvus en EC2

Este tema describe cómo implementar un clúster Milvus en Amazon EC2 con Terraform y Ansible.

Aprovisionar un cluster Milvus

Esta sección describe cómo utilizar Terraform para aprovisionar un cluster Milvus.

Terraform es una herramienta de software de infraestructura como código (IaC). Con Terraform, puede aprovisionar infraestructura utilizando archivos de configuración declarativos.

Requisitos previos

• Instalar y configurar Terraform

• Instalar y configurar AWS CLI

Preparar la configuración

Puede descargar archivos de configuración de plantillas en Google Drive.

• main.tf

  Este archivo contiene la configuración para aprovisionar un clúster Milvus.

• variables.tf

  Este archivo permite editar rápidamente las variables utilizadas para configurar o actualizar un clúster Milvus.

• output.tf y inventory.tmpl

  Estos archivos almacenan los metadatos de un cluster Milvus. Los metadatos utilizados en este tema son public_ip para cada instancia de nodo, private_ip para cada instancia de nodo y todos los ID de instancia EC2.

Preparar variables.tf

Esta sección describe la configuración que contiene un archivo variables.tf.

• Número de nodos

  La siguiente plantilla declara una variable index_count utilizada para establecer el número de nodos de índice.

  El valor de index_count debe ser mayor o igual a uno.

  variable "index_count" {
    description = "Amount of index instances to run"
    type        = number
    default     = 5
  }
  

• Tipo de instancia para un tipo de nodo

  La siguiente plantilla declara una variable index_ec2_type utilizada para establecer el tipo de instancia para los nodos índice.

  variable "index_ec2_type" {
    description = "Which server type"
    type        = string
    default     = "c5.2xlarge"
  }
  

• Permiso de acceso

  La siguiente plantilla declara una variable key_name y una variable my_ip. La variable key_name representa la clave de acceso de AWS. La variable my_ip representa el rango de direcciones IP para un grupo de seguridad.

  variable "key_name" {
    description = "Which aws key to use for access into instances, needs to be uploaded already"
    type        = string
    default     = ""
  }
  
  variable "my_ip" {
    description = "my_ip for security group. used so that ansible and terraform can ssh in"
    type        = string
    default     = "x.x.x.x/32"
  }
  

Preparar main.tf

Esta sección describe las configuraciones que contiene un archivo main.tf.

• Proveedor de nube y región

  La siguiente plantilla utiliza la región us-east-2. Consulte Regiones disponibles para obtener más información.

  provider "aws" {
    profile = "default"
    region  = "us-east-2"
  }
  

• Grupo de seguridad

  La siguiente plantilla declara un grupo de seguridad que permite el tráfico entrante desde el rango de direcciones CIDR representado por my_ip declarado en variables.tf.

  resource "aws_security_group" "cluster_sg" {
    name        = "cluster_sg"
    description = "Allows only me to access"
    vpc_id      = aws_vpc.cluster_vpc.id
  
    ingress {
      description      = "All ports from my IP"
      from_port        = 0
      to_port          = 65535
      protocol         = "tcp"
      cidr_blocks      = [var.my_ip]
    }
  
    ingress {
      description      = "Full subnet communication"
      from_port        = 0
      to_port          = 65535
      protocol         = "all"
      self             = true
    }
  
    egress {
      from_port        = 0
      to_port          = 0
      protocol         = "-1"
      cidr_blocks      = ["0.0.0.0/0"]
      ipv6_cidr_blocks = ["::/0"]
    }
  
    tags = {
      Name = "cluster_sg"
    }
  }
  

• VPC

  La siguiente plantilla especifica una VPC con el bloque CIDR 10.0.0.0/24 en un clúster Milvus.

  resource "aws_vpc" "cluster_vpc" {
    cidr_block = "10.0.0.0/24"
    tags = {
      Name = "cluster_vpc"
    }
  }
  
  resource "aws_internet_gateway" "cluster_gateway" {
    vpc_id = aws_vpc.cluster_vpc.id
  
    tags = {
      Name = "cluster_gateway"
    }
  }
  

• Subredes (opcional)

  La siguiente plantilla declara una subred cuyo tráfico se enruta a una pasarela de Internet. En este caso, el tamaño del bloque CIDR de la subred es el mismo que el bloque CIDR de la VPC.

  resource "aws_subnet" "cluster_subnet" {
    vpc_id                  = aws_vpc.cluster_vpc.id
    cidr_block              = "10.0.0.0/24"
    map_public_ip_on_launch = true
  
    tags = {
      Name = "cluster_subnet"
    }
  }
  
  resource "aws_route_table" "cluster_subnet_gateway_route" {
    vpc_id       = aws_vpc.cluster_vpc.id
  
    route {
      cidr_block = "0.0.0.0/0"
      gateway_id = aws_internet_gateway.cluster_gateway.id
    }
  
    tags = {
      Name = "cluster_subnet_gateway_route"
    }
  }
  
  resource "aws_route_table_association" "cluster_subnet_add_gateway" {
    subnet_id      = aws_subnet.cluster_subnet.id
    route_table_id = aws_route_table.cluster_subnet_gateway_route.id
  }
  
  

• Instancias de nodo (Nodos)

  La siguiente plantilla declara una instancia de nodo MinIO. El archivo de plantilla main.tf declara nodos de 11 tipos de nodo. Para algunos tipos de nodo, es necesario configurar root_block_device. Consulte Dispositivos EBS, efímeros y de bloque raíz para obtener más información.

  resource "aws_instance" "minio_node" {
    count         = var.minio_count
    ami           = "ami-0d8d212151031f51c"
    instance_type = var.minio_ec2_type
    key_name      = var.key_name
    subnet_id     = aws_subnet.cluster_subnet.id 
    vpc_security_group_ids = [aws_security_group.cluster_sg.id]
  
    root_block_device {
      volume_type = "gp2"
      volume_size = 1000
    }
    
    tags = {
      Name = "minio-${count.index + 1}"
    }
  }
  

Aplique la configuración

1. Abra un terminal y navegue hasta la carpeta que almacena main.tf.

2. Para inicializar la configuración, ejecute terraform init.

3. Para aplicar la configuración, ejecute terraform apply e introduzca yes cuando se le solicite.

Ahora ha aprovisionado un cluster Milvus con Terraform.

Iniciar el cluster Milvus

Esta sección describe cómo utilizar Ansible para iniciar el cluster Milvus que ha aprovisionado.

Ansible es una herramienta de gestión de configuración utilizada para automatizar el aprovisionamiento de la nube y la gestión de la configuración.

Requisitos previos

• Ansible Controller está instalado.

Descargar Ansible Milvus nodo despliegue Playbook

Clone el repositorio de Milvus desde GitHub para descargar el Manual de implementación de nodos Milvus de Ansible.

git clone https://github.com/milvus-io/milvus.git

Configurar los archivos de instalación

Los archivos inventory.ini y ansible.cfg se utilizan para controlar las variables de entorno y los métodos de verificación de inicio de sesión en Ansible playbook. En el archivo inventory.ini, la sección dockernodes define todos los servidores de motores Docker. La sección ansible.cfg define todos los servidores de coordinadores Milvus. La sección node define todos los servidores de los nodos Milvus.

Introduzca la ruta local al Playbook y configure los archivos de instalación.

$ cd ./milvus/deployments/docker/cluster-distributed-deployment

inventory.ini

Configure inventory.ini para dividir los hosts en grupos de acuerdo con sus roles en el sistema Milvus.

Añada nombres de host y defina el grupo docker y vars.

[dockernodes] #Add docker host names.
dockernode01
dockernode02
dockernode03

[admin] #Add Ansible controller name.
ansible-controller

[coords] #Add the host names of Milvus coordinators.
; Take note the IP of this host VM, and replace 10.170.0.17 with it.
dockernode01

[nodes] #Add the host names of Milvus nodes.
dockernode02

[dependencies] #Add the host names of Milvus dependencies.
; dependencies node will host etcd, minio, pulsar, these 3 roles are the foundation of Milvus. 
; Take note the IP of this host VM, and replace 10.170.0.19 with it.
dockernode03

[docker:children]
dockernodes
coords
nodes
dependencies

[docker:vars]
ansible_python_interpreter= /usr/bin/python3
StrictHostKeyChecking= no

; Setup variables to control what type of network to use when creating containers.
dependencies_network= host
nodes_network= host

; Setup varibale to control what version of Milvus image to use.
image= milvusdb/milvus-dev:master-20220412-4781db8a

; Setup static IP addresses of the docker hosts as variable for container environment variable config.
; Before running the playbook, below 4 IP addresses need to be replaced with the IP of your host VM
; on which the etcd, minio, pulsar, coordinators will be hosted.
etcd_ip= 10.170.0.19
minio_ip= 10.170.0.19
pulsar_ip= 10.170.0.19
coords_ip= 10.170.0.17

; Setup container environment which later will be used in container creation.
ETCD_ENDPOINTS= {{etcd_ip}}:2379 
MINIO_ADDRESS= {{minio_ip}}:9000
PULSAR_ADDRESS= pulsar://{{pulsar_ip}}:6650
QUERY_COORD_ADDRESS= {{coords_ip}}:19531
DATA_COORD_ADDRESS= {{coords_ip}}:13333
ROOT_COORD_ADDRESS= {{coords_ip}}:53100
INDEX_COORD_ADDRESS= {{coords_ip}}:31000

ansible.cfg

ansible.cfg Controla la acción del playbook, por ejemplo, clave SSH, etc. No configure la frase de contraseña a través de la clave SSH en hosts Docker. De lo contrario, la conexión SSH de Ansible fallará. Recomendamos configurar el mismo nombre de usuario y clave SSH en los tres hosts y configurar la nueva cuenta de usuario para ejecutar sudo sin contraseña. De lo contrario, recibirá errores de que el nombre de usuario no coincide con la contraseña o no se le conceden privilegios elevados al ejecutar Ansible playbook.

[defaults]
host_key_checking = False
inventory = inventory.ini # Specify the Inventory file
private_key_file=~/.my_ssh_keys/gpc_sshkey # Specify the SSH key that Ansible uses to access Docker host

deploy-docker.yml

deploy-docker.yml define las tareas durante la instalación de Docker. Consulte los comentarios de código en el archivo para obtener más detalles.

---
- name: setup pre-requisites # Install prerequisite
  hosts: all
  become: yes
  become_user: root
  roles:
    - install-modules
    - configure-hosts-file

- name: install docker
  become: yes
  become_user: root
  hosts: dockernodes
  roles:
    - docker-installation

Probar la conectividad con Ansible

Pruebe la conectividad con Ansible.

$ ansible all -m ping

Añada -i en el comando para especificar la ruta al archivo de inventario si no lo especificó en ansible.cfg, de lo contrario Ansible utiliza /etc/ansible/hosts.

El terminal devuelve lo siguiente:

dockernode01 | SUCCESS => {
"changed": false,
"ping": "pong"
}
ansible-controller | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python3"
    },
    "changed": false,
    "ping": "pong"
}
dockernode03 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
dockernode02 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Comprobar la sintaxis del Playbook

Compruebe la sintaxis del Playbook.

$ ansible-playbook deploy-docker.yml --syntax-check

Normalmente, el terminal devuelve lo siguiente:

playbook: deploy-docker.yml

Instalar Docker

Instala Docker con el Playbook.

$ ansible-playbook deploy-docker.yml

Si Docker se instala correctamente en los tres hosts, el terminal devuelve lo siguiente:

TASK [docker-installation : Install Docker-CE] *******************************************************************
ok: [dockernode01]
ok: [dockernode03]
ok: [dockernode02]

TASK [docker-installation : Install python3-docker] **************************************************************
ok: [dockernode01]
ok: [dockernode02]
ok: [dockernode03]

TASK [docker-installation : Install docker-compose python3 library] **********************************************
changed: [dockernode01]
changed: [dockernode03]
changed: [dockernode02]

PLAY RECAP *******************************************************************************************************
ansible-controller         : ok=3    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
dockernode01               : ok=10   changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
dockernode02               : ok=10   changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
dockernode03               : ok=10   changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Verificar la instalación

Inicie sesión en los tres hosts con la clave SSH y verifique la instalación en los hosts.

• Para el host root:

$ docker -v

• Para hosts no root:

$ sudo docker -v

Normalmente, el terminal muestra lo siguiente:

Docker version 20.10.14, build a224086

Compruebe el estado de ejecución de los contenedores.

$ docker ps

Compruebe la sintaxis

Compruebe la sintaxis de deploy-milvus.yml.

$ ansible-playbook deploy-milvus.yml --syntax-check

Normalmente, el terminal devuelve lo siguiente:

playbook: deploy-milvus.yml

Crear contenedor Milvus

Las tareas para crear el contenedor Milvus están definidas en deploy-milvus.yml.

$ ansible-playbook deploy-milvus.yml

El terminal devuelve:

PLAY [Create milvus-etcd, minio, pulsar] *****************************************************************

TASK [Gathering Facts] ********************************************************************************************
ok: [dockernode03]

TASK [etcd] *******************************************************************************************************
changed: [dockernode03]

TASK [pulsar] *****************************************************************************************************
changed: [dockernode03]

TASK [minio] ******************************************************************************************************
changed: [dockernode03]

PLAY [Create milvus nodes] ****************************************************************************************

TASK [Gathering Facts] ********************************************************************************************
ok: [dockernode02]

TASK [querynode] **************************************************************************************************
changed: [dockernode02]

TASK [datanode] ***************************************************************************************************
changed: [dockernode02]

TASK [indexnode] **************************************************************************************************
changed: [dockernode02]

PLAY [Create milvus coords] ***************************************************************************************

TASK [Gathering Facts] ********************************************************************************************
ok: [dockernode01]

TASK [rootcoord] **************************************************************************************************
changed: [dockernode01]

TASK [datacoord] **************************************************************************************************
changed: [dockernode01]

TASK [querycoord] *************************************************************************************************
changed: [dockernode01]

TASK [indexcoord] *************************************************************************************************
changed: [dockernode01]

TASK [proxy] ******************************************************************************************************
changed: [dockernode01]

PLAY RECAP ********************************************************************************************************
dockernode01               : ok=6    changed=5    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
dockernode02               : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
dockernode03               : ok=4    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Ahora tiene Milvus desplegado en los tres hosts.

Detener nodos

Puede detener todos los nodos cuando ya no necesite un cluster Milvus.

1. Ejecute terraform destroy e introduzca yes cuando se le solicite.

2. Si tiene éxito, se detendrán todas las instancias de nodos.

Qué hacer a continuación

Si desea aprender cómo desplegar Milvus en otras nubes:

• Despliegue un Cluster Milvus en EKS
• Despliegue un Cluster Milvus en GCP con Kubernetes
• Guía para implementar Milvus en Microsoft Azure con Kubernetes