Com escalar la infraestructura d'IA amb Kubernetes i Docker

Les empreses utilitzen cada cop més infraestructures d'intel·ligència artificial (IA) per allotjar i gestionar càrregues de treball autònomes. En conseqüència, hi ha hagut una demanda important d'escalables així com infraestructures resilients que podran satisfer els requisits heterogenis d'aplicacions o núvols. Ús de les organitzacions Kubernetes i Docker per satisfer aquestes necessitats perquè les empreses s'adonen que tots dos són casos d'ús altament eficaços que ofereixen infraestructures d'IA escalables.

El desplegament de la infraestructura d'IA normalment proporciona una potència de càlcul adequada per executar i processar grans conjunts de dades. Aquestes demandes es poden traduir en la necessitat de mètodes escalables que permetin que els models d'IA s'executin amb grans càrregues de treball sense perjudicar el rendiment.

Per què les empreses necessiten ampliar la seva infraestructura d'IA

Sistemes d'IA , no obstant això, també requereixen molts recursos, normalment exigeixen una gran capacitat de càlcul i la capacitat de processar alts nivells de dades. A mesura que es requereixen aplicacions d'IA més avançades i una escala més gran, l'escalabilitat es fa més crítica. L'escalabilitat garanteix que els sistemes d'IA puguin gestionar càrregues de treball creixents sense cap pèrdua de rendiment.

Ampliació del volum de dades

La creixent quantitat de dades és una preocupació per als sistemes d'IA en moltes facetes. La majoria dels models d'IA, especialment els basats en l'aprenentatge profund, depenen en gran mesura de grans quantitats de dades durant l'entrenament i la inferència. No obstant això, sense una infraestructura escalable adequada, el processament i la interpretació d'aquests quantitats enormes de dades és un obstacle .

Rendiment optimitzat

El maquinari d'IA escalable admet un rendiment fiable i estable malgrat les càrregues computacionals dràsticament aclaparadores. Amb Kubernetes, l'escala horitzontal de les feines d'IA és una brisa, i el redimensionament dinàmic dels números de rèpliques es pot fer en funció de la necessitat. En canvi, els contenidors Docker admeten entorns àgils i aïllats per executar models d'IA on el conflicte de recursos no és un coll d'ampolla de rendiment.

Gestió eficaç dels recursos

L'ús eficient dels recursos és la clau per a un desplegament d'IA sostenible i rendible. Les sol·licituds i els límits de recursos de Kubernetes permeten una gestió precisa dels recursos de memòria i CPU evitant el subprovisionament i el sobreprovisionament. La gestió de recursos de Docker omple el buit aïllant els recursos del contenidor.

Ampliació de la infraestructura d'IA amb Kubernetes i Docker

La contenerització és una de les fites en l'evolució de la infraestructura escalable d'intel·ligència artificial. La contenerització de l'aplicació d'IA i les seves dependències en un contenidor Docker garanteix la coherència en els entorns de desenvolupament, proves i desplegament.

Primer, heu de definir un Dockerfile per instal·lar l'entorn. El Dockerfile és una sèrie d'instruccions sobre com crear una imatge Docker. Declara una imatge base, les dependències necessàries i les ordres de configuració inicial que s'apliquen a la vostra aplicació. El següent és un Dockerfile bàsic per a un model d'aprenentatge automàtic de Python:

 # Use an official Python runtime as a parent image FROM python:3.9-slim # Set the working directory in the container WORKDIR /usr/src/app # Copy the current directory contents into the container COPY . . # Install any needed packages specified in requirements.txt RUN pip install --no-cache-dir -r requirements.txt # Expose the port the app runs on EXPOSE 5000 # Define environment variable ENV NAME World # Run the app CMD ["python", "./app.py"]

Si el Dockerfile està preparat, podeu crear la imatge Docker i executar el contenidor. Executeu les ordres següents:

 # Build the Docker image docker build -t ml-model:latest . # Run the container docker run -p 5000:5000 ml-model:latest

Desplegant el model d'IA Dockerized a Kubernetes

Kubernetes ofereix una àmplia gamma de funcions d'orquestració que permeten una gestió eficient d'aplicacions a la infraestructura en contenidors. El desplegament de la imatge de Docker a Kubernetes garanteix que un nombre especificat de rèpliques d'aplicació sempre s'executa. El següent és un exemple del fitxer deployment.yaml que podeu utilitzar desplega el teu model d'aprenentatge automàtic Dockerized :

 apiVersion: apps/v1 kind: Deployment metadata: name: ml-model-deployment spec: replicas: 3 selector: matchLabels: app: ml-model template: metadata: labels: app: ml-model spec: containers: - name: ml-model-container image: ml-model:latest ports: - containerPort: 5000

El fragment de codi anterior mostra com implementar el model d'IA, però també cal que el model sigui accessible des de l'exterior. Haureu d'exposar-lo definint un servei Kubernetes. El servei.yaml següent il·lustra un exemple:

 apiVersion: v1 kind: Service metadata: name: ml-model-service spec: selector: app: ml-model ports: - protocol: TCP port: 80 targetPort: 5000 type: LoadBalancer

Utilitzeu l'eina de línia d'ordres kubectl per aplicar les configuracions de desplegament i servei:

 # Deploy the application kubectl apply -f deployment.yaml # Expose the service kubectl apply -f service.yaml

Escalat amb Kubernetes

Kubernetes ofereix excel·lents capacitats d'escala als entorns d'IA, maximitzant la utilització i el rendiment dels recursos. L'escala horitzontal es fa afegint contenidors addicionals i l'escala vertical implica afegir recursos addicionals com la CPU o la memòria a un contenidor.

Escalat horitzontal

L'escalat horitzontal s'utilitza per augmentar el nombre de rèpliques (Pods) d'un sistema d'IA per gestionar una càrrega de treball més gran. El procés requereix habilitar l'escala dinàmica en funció del nombre de rèpliques. L'ordre que s'utilitza per habilitar aquest procés és "kubectl scale". L'ordre particular s'utilitza per configurar el desplegament perquè funcioni fins a un màxim de cinc rèpliques:

`kubectl scale --replicas=5 deployment/ml-model-deployment`

L'ordre escala el ml-model-deployment per utilitzar cinc rèpliques del contenidor del model d'aprenentatge automàtic. El sistema subministra de manera dinàmica més Pods per complir el nombre requerit després.

Escalat automàtic mitjançant l'Autoscaler de pods horitzontals (HPA)

Kubernetes facilita l'escalat automàtic mitjançant l'Horizontal Pod Autoscaler (HPA). L'HPA ajusta dinàmicament el nombre de rèpliques en funció de l'ús dels recursos, és a dir, CPU o memòria, en relació als límits establerts. La configuració YAML que es mostra a continuació és un exemple rellevant d'un HPA que s'escala dinàmicament per al desplegament del model ml en resposta a l'ús de la CPU:

 apiVersion: autoscaling/v1 kind: HorizontalPodAutoscaler metadata: name: ml-model-hpa spec: scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: ml-model-deployment minReplicas: 2 maxReplicas: 10 targetCPUUtilizationPercentage: 50

En aquesta configuració, scaleTargetRef s'utilitza per definir el desplegament que s'ha d'escalar, és a dir, ml-model-deployment. El recompte de rèpliques mínim s'estableix mitjançant MinReplicas, mentre que el recompte màxim de rèpliques es controla mitjançant maxReplicas. A més, el percentatge d'utilització de la CPU s'estableix mitjançant targetCPUUtilizationPercentage, és a dir, al 50%.

La utilització de la CPU de més del 50% en tots els pods fa que el nombre de rèpliques augmenti automàticament fins a un màxim de 10. Tan bon punt la utilització de la CPU cau per sota del percentatge establert, Kubernetes redueix automàticament el nombre de rèpliques per alliberar recursos.

Escalat vertical

L'escala horitzontal és principalment per fer front a més trànsit, mentre que l'escala vertical proporciona més recursos (com ara CPU o memòria) als contenidors existents. El procés consisteix a augmentar o reduir les sol·licituds de recursos i els límits al desplegament de Kubernetes. Per augmentar la CPU i els límits de memòria del ml-model-deployment, caldria obrir el fitxer deployment.yaml:

 apiVersion: apps/v1 kind: Deployment metadata: name: ml-model-deployment spec: replicas: 3 selector: matchLabels: app: ml-model template: metadata: labels: app: ml-model spec: containers: - name: ml-model-container image: ml-model:latest ports: - containerPort: 5000 resources: requests: cpu: "1" memory: "2Gi" limits: cpu: "2" memory: "4Gi"

En aquesta configuració actualitzada:

• les sol·licituds especifiquen els recursos mínims necessaris per al contenidor.
• els límits defineixen els recursos màxims que pot utilitzar el contenidor.