Acesso a dados otimizado para nuvem híbrida com base em ACK Fluid (2): Construindo uma ponte entre instâncias de computação elástica e armazenamento de terceiros

Zun Du e Fake Du, os programadores de Chengdu também são 996?

Revisão anterior:

Esta série apresentará como oferecer suporte e otimizar cenários de acesso a dados em nuvem híbrida baseados em ACK Fluid. Para artigos relacionados, consulte: "Otimizando o acesso a dados para nuvem híbrida com base em ACK Fluid (1): Cenários e arquitetura"

No artigo anterior "Acesso a dados otimizado para nuvem híbrida com base em ACK Fluid (1): cenários e arquitetura" , nos concentramos em apresentar os diferentes cenários de aplicativos e implementações de arquitetura para os quais o ACK Fluid oferece suporte ao acesso a dados em nuvem híbrida. Este artigo se concentrará em como usar o ACK Fluid para permitir que instâncias de computação elástica de nuvens públicas acessem sistemas de armazenamento em nuvem.

Visão geral

Os recursos de elasticidade prontos para uso do ACK (Alibaba Cloud Container Service Kubernetes) podem ser um bom complemento para os recursos de elasticidade dos IDCs autoconstruídos. Especialmente com a popularidade do AIGC, o conceito de poder computacional que impulsiona a inovação criou raízes nos corações das pessoas, e muitos clientes que originalmente resistiram à computação em nuvem começaram a avaliar as nuvens públicas. Eles geralmente optam por usar ECI (Elastic Compute Instance) como primeira etapa para verificação técnica. No entanto, como conectar o armazenamento autoconstruído com recursos elásticos na nuvem, especialmente recursos ECI, tornou-se o limite para os clientes da nuvem híbrida usarem o Alibaba Cloud. Por exemplo, um usuário deseja comparar rapidamente o custo de execução de tarefas de treinamento por meio do ASK na nuvem e de uma sala de informática autoconstruída na nuvem. A abordagem tradicional requer a movimentação de dados para a nuvem, o que também envolverá questões de privacidade de dados. como os custos de tempo e dinheiro da migração. Incapaz de fazer uma verificação rápida. Alguns clientes podem até não conseguir passar nas avaliações de segurança interna no curto prazo, fazendo com que todo o ritmo de inovação seja severamente afetado.

Pode-se observar que os dados de muitas empresas são armazenados off-line e usam uma variedade de tipos de armazenamento, incluindo vários armazenamentos de código aberto (Ceph, Lustrure, JuiceFS, CubeFS) e armazenamento autoconstruído. Também existem desafios ao usar recursos de computação em nuvem pública:

A avaliação da segurança e dos custos da migração de dados para a nuvem leva muito tempo: A migração de dados para o armazenamento na nuvem requer um longo período de avaliação por parte das equipes de segurança e armazenamento, o que atrasará todo o processo de migração para a nuvem.
Fraca adaptabilidade de acesso a dados: por exemplo, as nuvens públicas suportam tipos limitados de armazenamento distribuído (como NAS, OSS, CPFS) para instâncias de computação elástica (ECI), mas não suportam armazenamento de terceiros.
O acesso à plataforma em nuvem tem um ciclo longo e uma dificuldade elevada: é necessário desenvolver e manter plug-ins CSI compatíveis com os nativos da nuvem. Por um lado, requer especialistas relevantes e engenharia de desenvolvimento e adaptação e, ao mesmo tempo, versão as atualizações devem ser mantidas e os cenários suportados são limitados. Por exemplo, o CSI autoconstruído não pode ser adaptado a instâncias de computação elástica (ECI).
Falta de métodos de acesso a dados confiáveis e transparentes: como evitar vazamentos durante o acesso aos dados no sistema de caixa preta de contêineres sem servidor e como garantir que os dados sejam seguros, transparentes e confiáveis durante a transmissão e o acesso.
Evitar a necessidade de modificações nos negócios: Como garantir que os usuários empresariais não percebam diferenças no nível da infraestrutura e evitem quaisquer modificações no próprio aplicativo existente.

ACK Fluid suporta a integração de clientes de armazenamento de terceiros baseados em FUSE em Kubernetes de forma conteinerizada, fornecendo um mecanismo de extensão ThinRuntime.Ele pode suportar Kubernetes padrão, Kubernetes de borda e Kubernetes sem servidor no Alibaba Cloud.

Modo de acesso de desenvolvimento simples, fácil de expandir: Com base na solução ThinRuntime, você só precisa entender a construção do Dockerfile para concluir o trabalho de desenvolvimento.Geralmente, o trabalho de desenvolvimento leva cerca de 2 a 3 horas, reduzindo significativamente o custo de acesso a terceiros. armazenamento de festa. Ao mesmo tempo, fornece suporte completo para ThinRuntime baseado no padrão Fluid de código aberto, que pode ser adaptado desde que atenda aos requisitos de código aberto.
Acesso a dados seguro e controlável: ofereça suporte ao acesso a dados personalizados em contêineres. Todo o processo de acesso aos dados não é intrusivo para a plataforma em nuvem e não há necessidade de fornecer detalhes de implementação.
Não há necessidade de reduzir o custo de transformação e adaptação: basta adicionar uma etiqueta específica ao PVC, que atenda às necessidades dos usuários empresariais sem perceber diferenças no nível da infraestrutura, podendo encurtar o tempo de adaptação do armazenamento para um décimo de o plano original.
Implantação adaptativa de clientes de armazenamento: o Fluid oferece suporte aos modos de implantação de cliente CSI e FUSE Sidecar. Ele seleciona o modo de implantação apropriado de acordo com a plataforma em execução e converte o protocolo PVC em modo Sidecar sem o conhecimento do usuário final.
Observabilidade e controlabilidade aprimoradas: os clientes de armazenamento de terceiros só precisam implementar sua própria conteinerização e, em seguida, podem ser convertidos em pods gerenciados pelo Fluid, conectados perfeitamente ao sistema Kubernetes e obter observabilidade e controlabilidade dos recursos de computação.

Resumo: ACK Fluid ofereceas vantagens deboa escalabilidade, segurança e controlabilidade, baixo custo de adaptação e independência da implementação de plataforma em nuvem para[1].

Demonstração

Tomando o MinIO de código aberto como exemplo, ele mostra como conectar o armazenamento de terceiros aos recursos de computação elástica (ECI) do Alibaba Cloud por meio do Fluid.

1. Pré-requisitos

Um cluster da versão ACK Pro foi criado e a versão do cluster é 1.18 e superior. Para operações específicas, consulte Criando um cluster ACK Pro Edition [2] .
O conjunto de IA nativo da nuvem foi instalado e o componente ack-fluid foi implantado. Importante: Se você instalou o Fluid de código aberto, desinstale-o antes de implantar o componente ack-fluid.
O conjunto de IA nativo da nuvem não está instalado: ative a aceleração fluida de dados durante a instalação . Para operações específicas, consulte Instalando o Cloud Native AI Suite [3] .
O conjunto de IA nativo da nuvem foi instalado: Implante o ack-fluid na página do conjunto de IA nativo da nuvem do console de gerenciamento do Container Service.
O nó virtual ACK foi implementado. Para operações específicas, consulte Criando um pod ECI implantando o componente ACK Virtual Node [4] .
O cluster ACK foi conectado por meio do kubectl. Para operações específicas, consulte Conectando-se ao cluster por meio da ferramenta kubectl [5] .

2. Prepare o ambiente MinIO

Implante o armazenamento Minio no cluster ACK.

O seguinte arquivo YAML minio.yaml:

apiVersion: v1
kind: Service
metadata:
  name: minio
spec:
  type: ClusterIP
  ports:
    - port: 9000
      targetPort: 9000
      protocol: TCP
  selector:
    app: minio
---
apiVersion: apps/v1 #  for k8s versions before 1.9.0 use apps/v1beta2  and before 1.8.0 use extensions/v1beta1
kind: Deployment
metadata:
  # This name uniquely identifies the Deployment
  name: minio
spec:
  selector:
    matchLabels:
      app: minio
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        # Label is used as selector in the service.
        app: minio
    spec:
      containers:
      - name: minio
        # Pulls the default Minio image from Docker Hub
        image: bitnami/minio
        env:
        # Minio access key and secret key
        - name: MINIO_ROOT_USER
          value: "minioadmin"
        - name: MINIO_ROOT_PASSWORD
          value: "minioadmin"
        - name: MINIO_DEFAULT_BUCKETS
          value: "my-first-bucket:public"
        ports:
        - containerPort: 9000
          hostPort: 9000

Implante os recursos acima no cluster ACK:

$ kubectl create -f minio.yaml

Após a implantação bem-sucedida, outros pods no cluster ACK poderão acessar os dados no sistema de armazenamento Minio por meio do endpoint da API Minio em http://minio:9000 . Na configuração YAML acima, definimos o nome de usuário e a senha do Minio como minioadmin e criamos um bucket chamado my-first-bucket por padrão ao iniciar o armazenamento do Minio. No exemplo a seguir, acessaremos my-first-bucket Os dados neste balde. Antes de executar as etapas a seguir, primeiro execute o seguinte comando para armazenar o arquivo de amostra em my-first-bucket:

$ kubectl exec -it minio-69c555f4cf-np59j -- bash -c "echo fluid-minio-test > testfile"

$ kubectl exec -it minio-69c555f4cf-np59j -- bash -c "mc cp ./testfile local/my-first-bucket/" 

$ kubectl exec -it  minio-69c555f4cf-np59j -- bash -c "mc cat local/my-first-bucket/testfile"
fluid-minio-test

3. O administrador do cluster conecta o MinIO ao processo de desenvolvimento e implantação do Fluid

Como administrador de armazenamento MinIO, existem basicamente três etapas para acessar o Fluid. O seguinte processo de depuração pode ser concluído no Kubernetes de código aberto:

Desenvolva e crie imagens de contêiner MinIO
Desenvolva e implante o RuntimeProfile do MinIO
Crie um conjunto de dados Fluid que acesse MinIO e gere um volume de dados correspondente

3.1. Desenvolvimento e construção de imagens de containers

O Fluid passará os parâmetros de execução exigidos pelo FUSE no ThinRuntime, o ponto de montagem que descreve o caminho dos dados no Dataset e outros parâmetros para o contêiner ThinRuntime FUSE Pod. Dentro do contêiner, o script de análise de parâmetros precisa ser executado e os parâmetros de tempo de execução analisados são passados para o programa cliente FUSE, que então completa a montagem do sistema de arquivos Fuse no contêiner.

Portanto, ao usar ThinRuntime CRD para descrever um sistema de armazenamento, uma imagem de contêiner especial precisa ser usada e a imagem precisa incluir os dois programas a seguir:

Programa cliente FUSE
Script de análise de parâmetros de tempo de execução exigido pelo programa cliente FUSE

Para o programa cliente FUSE, neste exemplo, selecione o cliente goofys compatível com o protocolo S3 para conectar e montar o sistema de armazenamento minio.

Para o script de análise de parâmetros necessário em tempo de execução, defina o seguinte script python fluid-config-parse.py:

import json

with open("/etc/fluid/config.json", "r") as f:
    lines = f.readlines()

rawStr = lines[0]
print(rawStr)


script = """
#!/bin/sh
set -ex
export AWS_ACCESS_KEY_ID=`cat $akId`
export AWS_SECRET_ACCESS_KEY=`cat $akSecret`

mkdir -p $targetPath

exec goofys -f --endpoint "$url" "$bucket" $targetPath
"""

obj = json.loads(rawStr)

with open("mount-minio.sh", "w") as f:
    f.write("targetPath=\"%s\"\n" % obj['targetPath'])
    f.write("url=\"%s\"\n" % obj['mounts'][0]['options']['minio-url'])
    if obj['mounts'][0]['mountPoint'].startswith("minio://"):
      f.write("bucket=\"%s\"\n" % obj['mounts'][0]['mountPoint'][len("minio://"):])
    else:
      f.write("bucket=\"%s\"\n" % obj['mounts'][0]['mountPoint'])
    f.write("akId=\"%s\"\n" % obj['mounts'][0]['options']['minio-access-key'])
    f.write("akSecret=\"%s\"\n" % obj['mounts'][0]['options']['minio-access-secret'])

    f.write(script)

O script python acima é executado da seguinte forma:

Leia a string json no arquivo /etc/fluid/config.json e o Fluid armazenará e montará os parâmetros necessários para a montagem do cliente Fuse no arquivo /etc/fluid/config.json do contêiner Fuse.
Analise a string json e extraia os parâmetros necessários para a montagem do cliente Fuse. Por exemplo, parâmetros como url, bucket, minio-access-key, minio-access-secret no exemplo acima.
Depois de extrair os parâmetros necessários, envie o script de montagem para o arquivo mount-minio.sh.

⚠️Nota: No Fluid, o arquivo /etc/fluid/config.json fornece apenas o caminho de armazenamento do valor específico de cada parâmetro de criptografia, portanto, o script de análise de parâmetro precisa realizar operações adicionais de leitura de arquivo (por exemplo: "export AWS_ACCESS_KEY_ID in o exemplo acima =`cat $akId`").

Em seguida, use o seguinte Dockerfile para criar uma imagem. Aqui selecionamos diretamente a imagem que contém o programa cliente goofys (ou seja, cloudposse/goofys) como a imagem base do Dockerfile:

FROM cloudposse/goofys

RUN apk add python3 bash

COPY ./fluid-config-parse.py /fluid-config-parse.py

Use os seguintes comandos para construir e enviar a imagem para o repositório espelho:

$ IMG_REPO=<your image repo>

$ docker build -t $IMG_REPO/fluid-minio-goofys:demo .

$ docker push $IMG_REPO/fluid-minio-goofys:demo

3.2. Desenvolver e implantar ThinRuntimeProfile do MinIO

Antes de criar o Fluid Dataset e o ThinRuntime para montar o sistema de armazenamento Minio, primeiro você precisa desenvolver o recurso ThinRuntimeProfile CR. ThinRuntimeProfile é um recurso Fluid CRD em nível de cluster do Kubernetes. Ele descreve a configuração básica de um tipo de sistema de armazenamento que precisa ser conectado ao Fluid (por exemplo: contêineres, informações de descrição de recursos de computação, etc.). O administrador do cluster precisa definir vários recursos ThinRuntimeProfile CR no cluster com antecedência. Depois disso, o usuário do cluster precisa declarar explicitamente uma referência a um ThinRuntimeProfile CR para criar ThinRuntime para concluir a montagem do sistema de armazenamento correspondente.

A seguir está um exemplo de ThinRuntimeProfile CR para sistema de armazenamento MinIO (profile.yaml):

apiVersion: data.fluid.io/v1alpha1
kind: ThinRuntimeProfile
metadata:
  name: minio
spec:
  fileSystemType: fuse
  fuse:
    image: $IMG_REPO/fluid-minio-goofys
    imageTag: demo
    imagePullPolicy: IfNotPresent
    command:
    - sh
    - -c
    - "python3 /fluid-config-parse.py && chmod u+x ./mount-minio.sh && ./mount-minio.sh"

No exemplo CR acima:

fileSystemType descreve o tipo de sistema de arquivos (fsType) montado pelo ThinRuntime FUSE. Ele precisa ser preenchido de acordo com o programa cliente Fuse do sistema de armazenamento usado. Por exemplo, o fsType do ponto de montagem montado pelo goofys é fuse, e o fsType do ponto de montagem montado pelo s3fs é fuse.s3fs)
fuse descreve as informações do contêiner do ThinRuntime FUSE, incluindo informações da imagem (imagem, imageTag, imagePullPolicy) e comando de inicialização do contêiner (comando).

Crie o minio ThinRuntimeProfile CR e implante no cluster ACK.

3.3. Crie Dataset e ThinRuntime CR para montar e acessar os dados no sistema de armazenamento Minio.

Crie a credencial Secret necessária para acessar o minio:

$ kubectl create secret generic minio-secret \                                                                                   
  --from-literal=minio-access-key=minioadmin \ 
  --from-literal=minio-access-secret=minioadmin

Um exemplo de criação de um Dataset e ThinRuntime CR (dataset.yaml) para gerar um volume de dados de armazenamento disponível aos usuários:

apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: minio-demo
spec:
  mounts:
  - mountPoint: minio://my-first-bucket   # minio://<bucket name>
    name: minio
    options:
      minio-url: http://minio:9000  # minio service <url>:<port>
    encryptOptions:
      - name: minio-access-key
        valueFrom:
          secretKeyRef:
            name: minio-secret
            key: minio-access-key
      - name: minio-access-secret
        valueFrom:
          secretKeyRef:
            name: minio-secret
            key: minio-access-secret
---
apiVersion: data.fluid.io/v1alpha1
kind: ThinRuntime
metadata:
  name: minio-demo
spec:
  profileName: minio

Dataset.spec.mounts[*].mountPoint especifica o bucket de dados a ser acessado (por exemplo, my-frist-bucket)
Dataset.spec.mounts[*].options.minio-url especifica a URL que o minio pode acessar no cluster (por exemplo, http://minio:9000 )
ThinRuntime.spec.profileName especifica o ThinRuntimeProfile criado (por exemplo, minio-profile)

Crie conjunto de dados e CR ThinRuntime:

$ kubectl create -f dataset.yaml

Verifique o status do conjunto de dados. Após um período de tempo, você descobrirá que os status do conjunto de dados e da fase mudaram para vinculado e o conjunto de dados pode ser montado e usado normalmente:

$ kubectl get dataset minio-demo
NAME         UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
minio-demo                    N/A      N/A              N/A                 Bound   2m18s

4. Os usuários finais usam ECI (Elastic Container Instance) para acessar diretamente o MinIO por meio de PVC (aplicativo de volume de dados)

Para usuários finais, o processo de acesso ao MinIO é muito simples. A seguir está o arquivo YAML (pod.yaml) da amostra Pod Spec. Os usuários só precisam usar o PVC com o mesmo nome do conjunto de dados:

apiVersion: v1
kind: Pod
metadata:
  name: test-minio
  labels:
    alibabacloud.com/fluid-sidecar-target: eci
    alibabacloud.com/eci: "true"
spec:
  restartPolicy: Never
  containers:
    - name: app
      image: nginx:latest
      command: ["bash"]
      args:
      - -c
      - ls -lh /data && cat /data/testfile && sleep 180
      volumeMounts:
        - mountPath: /data
          name: data-vol
  volumes:
    - name: data-vol
      persistentVolumeClaim:
        claimName: minio-demo

http://alibabacloud.com/fluid-sidecar-target=eci identifica a necessidade de ativar o suporte específico do ACK Fluid para ECI
http://alibabacloud.com/eci indica que o nó virtual correspondente ao ECI está agendado no ACK

Crie um pod de acesso a dados:

$ kubectl create -f pod.yaml

Veja os resultados do pod de acesso a dados:

$ kubectl logs test-minio -c app
total 512
-rw-r--r-- 1 root root 6 Aug 15 12:32 testfile
fluid-minio-test

Pode-se observar que o Pod test-minio normalmente pode acessar os dados no sistema de armazenamento Minio.

5. Limpeza ambiental

$ kubectl delete -f pod.yaml
$ kubectl delete -f dataset.yaml
$ kubectl delete -f profile.yaml
$ kubectl delete -f minio.yaml

⚠️Atenção

Este exemplo é usado para mostrar todo o processo de acesso a dados, e a configuração do ambiente MinIO relacionado é apenas para fins de demonstração.

Links Relacionados:

[1]Xiaomi

https://www.infoq.cn/article/kco7hi5TcVE08ySwNIw7

[2] Criar cluster de versão ACK Pro

link

[3] Instale o pacote de IA nativo da nuvem

https://help.aliyun.com/zh/ack/cloud-native-ai-suite/user-guide/deploy-the-cloud-native-ai-suite#task-2038811

[4] Crie pod ECI implantando o componente de nó virtual ACK

https://help.aliyun.com/zh/ack/ack-gestion-and-ack-dedicated/user-guide/deploy-the-virtual-node-controller-and-use-it-to-create-elastic- pods baseados em instância de contêiner#task-1443354

[5] Conecte-se ao cluster por meio da ferramenta kubectl

https://help.aliyun.com/zh/ack/ack-gestion-and-ack-dedicated/user-guide/obtain-the-kubeconfig-file-of-a-cluster-and-use-kubectl-to- conecte-se ao cluster#task-ubf-lhg-vdb

Autor: Cheyang

Clique para experimentar o produto em nuvem gratuitamente agora para iniciar sua jornada prática na nuvem!

Link original

Este artigo é conteúdo original do Alibaba Cloud e não pode ser reproduzido sem permissão.