(Preterido) Implantar um cluster do Milvus no EC2

Este tópico descreve como implantar um cluster Milvus no Amazon EC2 com Terraform e Ansible.

Provisionar um cluster Milvus

Esta secção descreve como utilizar o Terraform para aprovisionar um cluster Milvus.

O Terraform é uma ferramenta de software de infraestrutura como código (IaC). Com o Terraform, é possível provisionar a infraestrutura usando arquivos de configuração declarativos.

Pré-requisitos

• Instalar e configurar o Terraform

• Instalar e configurar o AWS CLI

Preparar a configuração

Pode transferir ficheiros de configuração modelo no Google Drive.

• main.tf

  Este ficheiro contém a configuração para o aprovisionamento de um cluster Milvus.

• variables.tf

  Este ficheiro permite uma edição rápida das variáveis utilizadas para configurar ou atualizar um cluster Milvus.

• output.tf e inventory.tmpl

  Estes ficheiros armazenam os metadados de um cluster Milvus. Os metadados usados neste tópico são public_ip para cada instância de nó, private_ip para cada instância de nó e todos os IDs de instância do EC2.

Preparar variables.tf

Esta secção descreve a configuração que um ficheiro variables.tf contém.

• Número de nós

  O modelo a seguir declara uma variável index_count usada para definir o número de nós de índice.

  O valor de index_count deve ser maior ou igual a um.

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

• Tipo de instância para um tipo de nó

  O modelo seguinte declara uma variável index_ec2_type utilizada para definir o tipo de instância para os nós de índice.

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

• Permissão de acesso

  O modelo seguinte declara uma variável key_name e uma variável my_ip. A variável key_name representa a chave de acesso do AWS. A variável my_ip representa o intervalo de endereços IP para um grupo de segurança.

  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 secção descreve as configurações que um ficheiro main.tf contém.

• Provedor de nuvem e região

  O modelo a seguir usa a região us-east-2. Consulte Regiões disponíveis para obter mais informações.

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

• Grupo de segurança

  O modelo a seguir declara um grupo de segurança que permite o tráfego de entrada do intervalo de endereços CIDR representado por my_ip declarado em 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

  O modelo a seguir especifica uma VPC com o bloco CIDR 10.0.0.0/24 em um cluster 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"
    }
  }
  

• Sub-redes (opcional)

  O modelo a seguir declara uma sub-rede cujo tráfego é encaminhado para um gateway de Internet. Neste caso, o tamanho do bloco CIDR da sub-rede é o mesmo que o bloco CIDR da 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
  }
  
  

• Instâncias de nó (Nodes)

  O seguinte modelo declara uma instância de nó MinIO. O ficheiro de modelo main.tf declara nós de 11 tipos de nós. Para alguns tipos de nós, é necessário definir root_block_device. Consulte EBS, Ephemeral e Dispositivos de bloco raiz para obter mais informações.

  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}"
    }
  }
  

Aplicar a configuração

1. Abra um terminal e navegue até a pasta que armazena main.tf.

2. Para inicializar a configuração, execute terraform init.

3. Para aplicar a configuração, execute terraform apply e introduza yes quando solicitado.

Agora você provisionou um cluster do Milvus com o Terraform.

Iniciar o cluster do Milvus

Esta secção descreve como utilizar o Ansible para iniciar o cluster do Milvus que foi aprovisionado.

O Ansible é uma ferramenta de gerenciamento de configuração usada para automatizar o provisionamento de nuvem e o gerenciamento de configuração.

Pré-requisitos

• O Ansible Controller está instalado.

Baixar o Playbook de implantação de nó do Milvus do Ansible

Clone o repositório Milvus do GitHub para baixar o Playbook de implantação de nó do Ansible Milvus.

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

Configurar ficheiros de instalação

Os ficheiros inventory.ini e ansible.cfg são utilizados para controlar as variáveis de ambiente e os métodos de verificação de início de sessão no manual do Ansible. No ficheiro inventory.ini, a secção dockernodes define todos os servidores de motores de docker. A secção ansible.cfg define todos os servidores dos coordenadores Milvus. A secção node define todos os servidores dos nós Milvus.

Introduza o caminho local para o Playbook e configure os ficheiros de instalação.

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

inventory.ini

Configure o inventory.ini para dividir os hosts em grupos de acordo com as suas funções no sistema Milvus.

Adicionar os nomes dos anfitriões, definir o grupo docker e 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 a ação do playbook, por exemplo, a chave SSH, etc. Não configure a frase-passe através da chave SSH em anfitriões docker. Caso contrário, a conexão SSH do Ansible falhará. Recomendamos configurar o mesmo nome de usuário e chave SSH nos três hosts e configurar a nova conta de usuário para executar o sudo sem uma senha. Caso contrário, receberá erros que indicam que o nome de utilizador não corresponde à palavra-passe ou que não lhe são concedidos privilégios elevados ao executar o playbook do Ansible.

[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 as tarefas durante a instalação do Docker. Consulte os comentários de código no arquivo para obter detalhes.

---
- 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

Testar a conetividade do Ansible

Teste a conetividade com o Ansible.

$ ansible all -m ping

Adicione -i no comando para especificar o caminho para o ficheiro de inventário se não o tiver especificado em ansible.cfg, caso contrário o Ansible utiliza /etc/ansible/hosts.

O terminal retorna o seguinte:

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"
}

Verificar a sintaxe do Playbook

Verifique a sintaxe do Playbook.

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

Normalmente, o terminal retorna o seguinte:

playbook: deploy-docker.yml

Instalar o Docker

Instale o Docker com o Playbook.

$ ansible-playbook deploy-docker.yml

Se o Docker for instalado com êxito nos três hosts, o terminal retornará o seguinte:

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 a instalação

Faça login nos três hosts com a chave SSH e verifique a instalação nos hosts.

• Para o host raiz:

$ docker -v

• Para hosts não-root:

$ sudo docker -v

Normalmente, o terminal retorna como a seguir:

Docker version 20.10.14, build a224086

Verificar o estado de execução dos contentores.

$ docker ps

Verificar a sintaxe

Verificar a sintaxe de deploy-milvus.yml.

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

Normalmente, o terminal retorna o seguinte:

playbook: deploy-milvus.yml

Criar o contentor Milvus

As tarefas para criar o contentor Milvus estão definidas em deploy-milvus.yml.

$ ansible-playbook deploy-milvus.yml

O terminal retorna:

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

Agora você tem o Milvus implantado nos três hosts.

Parar os nós

Pode parar todos os nós depois de já não precisar de um cluster Milvus.

1. Execute terraform destroy e introduza yes quando solicitado.

2. Se for bem-sucedido, todas as instâncias de nós serão interrompidas.

O que se segue

Se você quiser aprender como implantar o Milvus em outras nuvens:

• Implantar um cluster do Milvus no EKS
• Implantar o cluster do Milvus no GCP com o Kubernetes
• Guia de implantação do Milvus no Microsoft Azure com o Kubernetes