introdução oficial

MinIO é um serviço de armazenamento de objetos baseado no protocolo de código aberto Apache License v2.0. É compatível com a interface do serviço de armazenamento em nuvem Amazon S3 e é muito adequado para armazenar dados não estruturados de grande capacidade , como imagens, vídeos, arquivos de log, dados de backup e imagens de contêiner/máquina virtual, etc., e um arquivo de objeto pode ser de qualquer tamanho, de vários kb até no máximo 5T

O MinIO pode ser implantado em um único ponto, implantação de cluster distribuído, fácil de operar e implantar e pode suportar expansão. O SDK é semelhante ao Ali OSS, que atende às minhas necessidades. A única falha é que ele não oferece suporte à expansão dinâmica.

Implantação de nó único do Docker

Primeiro puxe o espelho e baixe a versão mais recente do espelho

docker pull minio/minio

Inicie o contêiner, a porta inicial é 9000 "-v /mnt/data:/data", especifique o endereço de armazenamento do host apontando para o contêiner, o arquivo carregado é armazenado aqui, o comando para iniciar "server /data", especifique o endereço de armazenamento interno do contêiner como / dados

docker run -p 9000:9000 --name minio1 \
 --restart=always \
 --net=host \
  -e MINIO_ACCESS_KEY=minioadmin \
   -e MINIO_SECRET_KEY=minioadmin \
  -v /mnt/data:/data \
  -v /mnt/config:/root/.minio \
  minio/minio server /data

Depois que a inicialização for bem-sucedida, o navegador visita http://{ip}:9000, accessKey e secretKey são necessários para o login e o contêiner docker começa com "minioadmin" por padrão, que será exibido após a inicialização

Implantação binária de nó único do Linux

download

mkdir /home/minio/{app,config,data,logs} -p
cd /home/minio/app
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio

Criar diretório de dados

mkdir /minio_data

script de inicialização

min_server_start.sh

chmod 755 min_server_single.sh

#!/bin/bash
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app	
nohup ${MINIO_HOME}/minio server /minio_data  --address :9000 --console-address :8000 > ${MINIO_HOME}/minio.log 2>&1 &

script de inicialização

bash min_server_single.sh

Depois que a inicialização for bem-sucedida, o navegador visita http://{ip}:9000, accessKey e secretKey são necessários para o login, que são admin/12345678 no script, respectivamente

Implantação distribuída do Linux

Introdução oficial: Minio distribuído requer pelo menos 4 discos rígidos , e o uso de Minio distribuído introduz automaticamente a função de código de eliminação.

Vantagens do Minio Distribuído

O Data Protection
Distributed Minio usa códigos de eliminação para evitar tempo de inatividade de vários nós e podridão de bits.
O Minio distribuído requer pelo menos 4 discos rígidos e o uso do Minio distribuído introduz automaticamente a função de código de eliminação.

Há um único ponto de falha no serviço Minio autônomo altamente disponível
. Pelo contrário, se for um Minio distribuído com N discos rígidos, desde que haja N/2 discos rígidos online, seus dados estarão seguros. Mas você precisa de pelo menos N/2+1 discos rígidos para criar novos objetos .
Por exemplo, um cluster Minio de 16 nós com 16 discos rígidos por nó, mesmo que 8 servidores fiquem inativos, o cluster ainda é legível, mas você precisa de 9 servidores para gravar dados.

Consistência
Minio em modo distribuído e autônomo, todas as operações de leitura e gravação obedecem estritamente ao modelo de consistência de leitura após gravação

preparar o ambiente

192.168.10.159 lacaio-2
192.168.10.153 lacaio-1

4 discos rígidos por nó

Nota: Deve haver quatro discos rígidos e o disco rígido está vazio, caso contrário, um erro será relatado.

#创建挂载点
mkdir /mnt/mongo1
mkdir /mnt/mongo2
mkdir /mnt/mongo3
mkdir /mnt/mongo4
#分区
fdisk /dev/sdc
fdisk /dev/sdd
fdisk /dev/sde
fdisk /dev/sdf
#格式化
mkfs.ext4 /dev/sdc1
mkfs.ext4 /dev/sdd1
mkfs.ext4 /dev/sde1
mkfs.ext4 /dev/sdf1
#加载
mount /dev/sdc1 /mnt/mongo2/
mount /dev/sdd1 /mnt/mongo3/
mount /dev/sde1 /mnt/mongo4/
mount /dev/sdf1 /mnt/mongo1/
#写入系统配置
echo "/dev/sdc1 /mnt/mongo2 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdd1 /mnt/mongo3 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sde1 /mnt/mongo4 ext4 defaults 0 0" >> /etc/fstab
echo "/dev/sdf1 /mnt/mongo1 ext4 defaults 0 0" >> /etc/fstab

df-h

Verifique se os relógios estão sincronizados

Sincronização automática do tempo de configuração do servidor Centos

script de layout

Observação: pule métodos de implantação não escaláveis e métodos de implantação pseudodistribuídos aqui.

Primeiro, inicie o cluster de nó único minio-1 (você precisa tentar expandir o cluster mais tarde)

minio_cluster.sh

chmod 755 minio_cluster.sh

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app
nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-1/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

Iniciar o cluster

bash chmod 755 minio_cluster.sh

verificar

Método de expansão de cluster

expansão ponto a ponto

Em primeiro lugar, o conceito de design minimalista do MinIO faz com que o cluster distribuído do MinIO não suporte o método de expansão de adicionar um único nó ao cluster e realizar o ajuste automático. Isso ocorre porque o equilíbrio de dados e a divisão do grupo de eliminação causados pela adição de um único nó serão causa Traz procedimentos complexos de agendamento e processamento para todo o cluster, o que não é propício para manutenção. Portanto, o MinIO fornece um método de expansão ponto a ponto, ou seja, o número de nós e discos necessários para aumentar deve ser igual ao cluster original.

Nota: Cada região adicionada deve ter o mesmo número de discos (conjunto de códigos de eliminação) que a região original para manter o mesmo SLA de redundância de dados .
Por exemplo, a primeira zona tem 8 discos, você pode expandir o cluster para zonas de 16, 32 ou 1024 discos, apenas certifique-se de que o SLA de implantação seja um múltiplo da zona original.

O script de inicialização do nó minio-1 adiciona configuração

Para expansão de capacidade, adicione o nó expandido no final da última linha do comando original e reinicie o cluster.

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app
nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-1/mnt/mongo{1...4} http://minio-2/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

Sincronizar script de inicialização

Sincronize o script de inicialização com o nó minio-2 e, em seguida, ambos os nós iniciam o serviço.

verificar

expansão da federação

O MinIO fornece oficialmente outro mecanismo de expansão - expansão federada, ou seja, ao introduzir o etcd, vários clusters distribuídos MinIO são formados logicamente em uma federação e os serviços externos são fornecidos como um todo e um namespace unificado é fornecido. A arquitetura do cluster federado MinIO é mostrada na Figura 3-1.

Vantagens e desvantagens da expansão federada

Em comparação com a expansão ponto a ponto, as vantagens da expansão da federação são: ① cada cluster na federação não requer que o número de nós e discos seja igual; ② a federação pode ser expandida indefinidamente e novos clusters são adicionados continuamente; ③ se um cluster na federação falhar, a falha não afetará outros clusters na federação para fornecer serviços. A desvantagem é que o etcd precisa ser introduzido adicionalmente e o processo de configuração é mais complicado.

Foi verificado que o cluster federado possui uma falha. Quando o cluster A está cheio, apenas o cluster A pode ser expandido, caso contrário, os buckets relacionados a A não podem ser adicionados. A expansão do cluster B é inválida .

instalar etcd

Local de instalação: 192.168.10.153

yum install -y etcd

vi /etc/etcd/etcd.conf

#[Member]
#ETCD_CORS=""
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
#ETCD_WAL_DIR=""
ETCD_LISTEN_PEER_URLS="http://0.0.0.0:3380"
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0. 0,0:
3379" #ETCD_MAX_SNAPSHOTS="5"
#ETCD_MAX_WALS="5"
ETCD_NAME="etcd_minio"
#ETCD_SNAPSHOT_COUNT="100000"
#ETCD_HEARTBEAT_INTERVAL="100"
#ETCD_ELECTION_TIMEOUT="1000"
#ETCD_QUOTA_BACKEND_BYTES="0"
#ETCD_MAX_REQUEST_ BYTES="1572864"
# ETCD_GRPC_KEEPALIVE_MIN_TIME="5s"
#ETCD_GRPC_KEEPALIVE_INTERVAL="2h0m0s"
#ETCD_GRPC_KEEPALIVE_TIMEOUT="20s"
#
#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://192.168.10.153:3380"
ETCD_ADVERTISE_CLIENT_URLS="http://192.168.10.153:3379"
#ETCD_DISCOVERY=""
#ETCD_DISCOVERY_FALLBACK="proxy"
#ETCD_DISCOVERY_PROXY=""
#ETCD_DISCOVERY_SRV=""
#ETCD_INITIAL_CLUSTER="default=http://localhost:2380"
#ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
#ETCD_INITIAL_CLUSTER_STATE="novo"
#ETCD_STRICT_RECONFIG_CHECK="true"
#ETCD_ENABLE_V2="true"
#
#[Proxy]
#ETCD_PROXY="off"
#ETCD_PROXY_FAILURE_WAIT="5000"
#ETCD_PROXY_ REFRESH_INTERVAL="30000 "
#ETCD_PROXY_DIAL_TIMEOUT="1000"
#ETCD_PROXY_WRITE_TIMEOUT="5000"
#ETCD_PROXY_READ_TIMEOUT="0"
#
#[Segurança]
#ETCD_CERT_FILE=""
#ETCD_KEY_FILE=""
#ETCD_CLIENT_CERT_AUTH="false"
#ETCD_TRUSTED_CA_FILE=""
#ETCD_AUTO_TLS="false" #
ETCD_PEER_CERT_FILE="
" #ETCD_PEER_KEY_FILE ="" #ETCD_PEER_CLIENT_CERT_AUTH="false" #ETCD_PEER_TRUSTED_CA_FILE="" #ETCD_ PEER_AUTO_TLS="falso" # #[Logging] #ETCD_DEBUG="false" #ETCD_LOG_PACKAGE_LEVELS="" #ETCD_LOG_OUTPUT="default" # #[Unsafe] #ETCD_FORCE_NEW_CLUSTER="false" # #[Version] #ETCD_VERSION="false" #ETCD_AUTO_COMPACTION_RETENTION="0" ##[Profiling] #ETCD_ENABLE_PPROF="false" #ETCD_METRICS="basic" #

#[Auth]
#ETCD_AUTH_TOKEN="simples"

Certifique-se de que o etcd foi instalado com sucesso. Você pode verificar o status da instalação do etcd com o seguinte comando:

rpm -qa | grep etcd

Se as informações da versão do etcd forem exibidas na saída, o etcd já está instalado.

Inicie o serviço etcd. Inicie o etcd com o seguinte comando:

systemctl start etcd

Isso inicia o serviço etcd em funcionamento.

Verifique se o serviço etcd foi iniciado com sucesso. Você pode usar o seguinte comando para verificar o status de execução do serviço etcd:

status systemctl etcd

Se ativo (em execução) for exibido na saída, o serviço etcd foi iniciado com sucesso.

Script de inicialização do cluster 1

minio_cluster.sh

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app

export MINIO_ETCD_ENDPOINTS="http://192.168.10.153:3379"
export MINIO_PUBLIC_IPS=192.168.10.153
export MINIO_DOMAIN=bo.test.com


nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-1/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

Script de inicialização do cluster 2

minio_cluster.sh

#!/bin/bash
  
export MINIO_ROOT_USER=admin
export MINIO_ROOT_PASSWORD=12345678
MINIO_HOME=/home/minio/app

export MINIO_ETCD_ENDPOINTS="http://192.168.10.153:3379"
export MINIO_PUBLIC_IPS=192.168.10.159
export MINIO_DOMAIN=bo.test.com

nohup ${MINIO_HOME}/minio server --address :9000 --console-address :8000  \
        http://minio-2/mnt/mongo{1...4} > ${MINIO_HOME}/minio.log 2>&1 &

explicação de configuração

O parâmetro MINIO_ETCD_ENDPOINTS precisa corresponder aos IPs de todos os nós no cluster ETCD construído;

O parâmetro MINIO_PUBLIC_IPS é o IP de todos os nós do cluster;

O parâmetro MINIO_DOMAIN deve ser configurado. Mesmo que você não acesse o bucket por meio de um nome de domínio, caso contrário, a federação não terá efeito. Somente clusters com o mesmo valor do parâmetro MINIO_DOMAIN formarão uma federação.

verificar

Crie um Bucket no cluster A e, se puder ser visto imediatamente no cluster B, significa que o cluster foi criado com sucesso.

expansão ponto a ponto de implantação do docker

cena de demanda

O método de implantação do cluster original requer pelo menos 4 discos rígidos vazios e requer muitos recursos. Às vezes, quando os recursos são limitados, é necessário um cluster que possa expandir os recursos de armazenamento , que pode ser implantado na forma de docker.

O cluster minio instalado pelo docker pode usar uma pasta em vez de um disco, e o diretório de dados do cluster minio de instalação original deve usar um disco inteiro vazio.
A versão cluster também usa códigos de apagamento para manter os dados, garantindo o backup dos dados (embora apenas em pastas), e a versão autônoma não usa códigos de apagamento.
Recomenda-se usar um diretório de dados e um disco no ambiente de produção.

Lista de servidores

192.168.10.159,192.168.10.160

ponto importante

1. A rede deve usar o modo --net-host. Depois de experimentar o modo de mapeamento, ele não está disponível . O palpite é que, ao usar o modo de mapeamento, ao relatar a identidade de cada nó para o cluster, o IP obtido é o IP do contêiner interno, que é inconsistente com o endereço IP dos dados nos parâmetros a seguir.

2. Se os dados precisarem ser mantidos, o diretório de dados e o diretório do arquivo de configuração precisam ser mapeados para o host

3. A porta de serviço e a porta do console podem ser personalizadas usando os parâmetros --address, --console-address

4. Recomenda-se que o número de cópias de todos os discos seja 2 elevado à enésima potência, maior ou igual a 4

Construir Dockerfile

FROM centos:centos7.9.2009
wget https://dl.min.io/server/minio/release/linux-amd64/minio
WORKDIR /opt
RUN  chmod +x minio
ENTRYPOINT ["./minio"]
CMD ["server", "--address :9000","--console-address :9999","http://10.22.1.27/data{1...4}"]

Se o arquivo minio foi baixado, você pode usar

FROM centos:centos7.9.2009
COPY ./minio /opt/
WORKDIR /opt
RUN  chmod +x minio
ENTRYPOINT ["./minio"]
CMD ["server", "--address :9000","--console-address :9999","http://10.22.1.27/data{1...4}"]

construir imagem de construção

sudo docker build -t myminio .

script de inicialização

docker run   --name minio1   \
    --restart=always \
    --net=host \
    -e MINIO_ACCESS_KEY=minioadmin \
    -e MINIO_SECRET_KEY=minioadmin \
    -v /data1:/data1 \
    -v /data2:/data2 \
	-v /data3:/data3 \
    -v /data4:/data4 \
    myminio server \
    --address :29000 \
    --console-address :29001  \
    http://192.168.10.159/data{1...4} http://192.168.10.160/data{1...4}

Perceber:

1. O motivo pelo qual o wget obtém o arquivo minio acima não é a imagem minio/minio padrão. O experimento descobriu que usar a sintaxe {} para a imagem minio/minio relatará um erro, então o arquivo binário mais recente é usado diretamente.

2. Às vezes, se o diretório de mapeamento inicializado já existir, um erro pode ser relatado na inicialização. A maneira mais segura é garantir que o diretório não exista e permitir que o docker o crie automaticamente ao iniciar.

Forneça uma ideia de expansão reversa

Monte o máximo de diretórios possível primeiro e, quando o diretório de dados estiver quase cheio, mova parte do diretório de dados para um novo disco rígido vazio, exclua o contêiner, modifique o caminho de montagem no script de inicialização e reinicie. Se 32 diretórios forem montados, haverá 5 oportunidades de expansão e, se 16 diretórios forem montados, haverá 5 oportunidades de expansão. Se houver 8 diretórios, haverá 4 oportunidades de expansão. Por fim, se não houver oportunidade de expandir o diretório mv, você poderá adicionar nós de máquina.

Por exemplo, primeiro monte 16 diretórios

docker run   --name minio1  -d \
    --restart=always \
    --net=host \
    -e MINIO_ACCESS_KEY=minioadmin \
    -e MINIO_SECRET_KEY=minioadmin \
    -v /mnt/mongo1/data1:/data1 \
    -v /mnt/mongo1/data2:/data2 \
	-v /mnt/mongo1/data3:/data3 \
    -v /mnt/mongo1/data4:/data4 \
	-v /mnt/mongo1/data5:/data5 \
    -v /mnt/mongo1/data6:/data6 \
	-v /mnt/mongo1/data7:/data7 \
    -v /mnt/mongo1/data8:/data8 \
	-v /mnt/mongo1/data9:/data9 \
    -v /mnt/mongo1/data10:/data10 \
	-v /mnt/mongo1/data11:/data11 \
    -v /mnt/mongo1/data12:/data12 \
	-v /mnt/mongo1/data13:/data13 \
    -v /mnt/mongo1/data14:/data14 \
	-v /mnt/mongo1/data15:/data15 \
    -v /mnt/mongo1/data16:/data16 \
    myminio server  \
    --address :29000 \
    --console-address :29001  \
    http://192.168.10.159:29000/data{1...16}

Quando o disco rígido onde /mnt/mongo1 está localizado estiver quase cheio, mova 9-16 para um novo disco rígido

mv /mnt/mongo1/data9 /total_min/
mv /mnt/mongo1/data10 /total_min/
mv /mnt/mongo1/data11 /total_min/
mv /mnt/mongo1/data12 /total_min/
mv /mnt/mongo1/data13 /total_min/
mv /mnt/mongo1/data14 /total_min/
mv /mnt/mongo1/data15 /total_min/
mv /mnt/mongo1/data16 /total_min/

Exclua o contêiner, modifique o script de inicialização e reinicie o contêiner, para que o efeito de expansão seja ativado e a verificação experimental seja efetiva.

docker run   --name minio1  -d \
    --restart=always \
    --net=host \
    -e MINIO_ACCESS_KEY=minioadmin \
    -e MINIO_SECRET_KEY=minioadmin \
    -v /mnt/mongo1/data1:/data1 \
    -v /mnt/mongo1/data2:/data2 \
	-v /mnt/mongo1/data3:/data3 \
    -v /mnt/mongo1/data4:/data4 \
	-v /mnt/mongo1/data5:/data5 \
    -v /mnt/mongo1/data6:/data6 \
	-v /mnt/mongo1/data7:/data7 \
    -v /mnt/mongo1/data8:/data8 \
	-v /total_min/data9:/data9 \
    -v /total_min/data10:/data10 \
	-v /total_min/data11:/data11 \
    -v /total_min/data12:/data12 \
	-v /total_min/data13:/data13 \
    -v /total_min/data14:/data14 \
	-v /total_min/data15:/data15 \
    -v /total_min/data16:/data16 \
    myminio server  \
    --address :29000 \
    --console-address :29001  \
    http://192.168.10.159:29000/data{1...16}

Você também não pode excluir o contêiner. Depois de mover o arquivo, use ln para criar um link de arquivo para apontar para o local original

 ln -s /mnt/mongo2/data9 /mnt/mongo1/data9
 ln -s /mnt/mongo2/data10 /mnt/mongo1/data10
 ln -s /mnt/mongo2/data11 /mnt/mongo1/data11
 ln -s /mnt/mongo2/data12 /mnt/mongo1/data12
 ln -s /mnt/mongo2/data13 /mnt/mongo1/data13
 ln -s /mnt/mongo2/data14 /mnt/mongo1/data14
 ln -s /mnt/mongo2/data15 /mnt/mongo1/data15
 ln -s /mnt/mongo2/data16 /mnt/mongo1/data16

Conforme mostrado na figura, você pode reiniciar o contêiner sem modificar o comando docker startup.