Hur man skalar AI-infrastruktur med Kubernetes och Docker

Företag använder sig allt mer av artificiell intelligens (AI) infrastrukturer för att vara värd för och hantera autonoma arbetsbelastningar. Följaktligen, det har funnits en betydande efterfrågan på skalbara samt motståndskraftiga infrastrukturer som kommer att kunna möta heterogena applikations- eller molnkrav. Organisationer använder Kubernetes och Hamnarbetare för att möta sådana behov eftersom företagen inser att båda är mycket effektiva användningsfall som levererar skalbar AI-infrastruktur.

Att distribuera AI-infrastruktur ger vanligtvis tillräcklig beräkningskraft för att exekvera och bearbeta stora datamängder. Dessa krav kan översättas till behovet av skalbara metoder som gör att AI-modeller kan köras på stora arbetsbelastningar utan att skada prestandan.

Varför företag behöver skala upp sin AI-infrastruktur

AI-system likväl är de också resurskrävande och kräver normalt både hög beräkningskapacitet och förmåga att bearbeta höga datanivåer. När mer avancerade AI-applikationer och en större skala krävs, blir skalbarheten mer kritisk. Skalbarhet säkerställer att AI-system kan hantera ökande arbetsbelastningar utan förlust av prestanda.

Utöka datavolymer

Den växande mängden data är ett problem för AI-system i många aspekter. De flesta AI-modeller, särskilt de som bygger på djupinlärning, är starkt beroende av stora mängder data under träning och slutledning. Men utan tillräcklig skalbar infrastruktur, bearbetning och tolkning av sådan enorma mängder data är en vägspärr .

Optimerad prestanda

Skalbar AI-hårdvara stöder pålitlig och stabil prestanda trots drastiskt överväldigande beräkningsbelastningar. Med Kubernetes är horisontell skalning av AI-jobb enkelt, och den dynamiska storleksändringen av repliknummer kan göras som en funktion av nödvändighet. Däremot stöder Docker-containrar slanka, isolerade miljöer för att köra AI-modeller där resurskonflikt inte är en prestandaflaskhals.

Effektiv resurshantering

Effektiv användning av resurser är nyckeln till kostnadseffektiv och hållbar AI-utbyggnad. Kubernetes resursbegäranden och begränsningar möjliggör finkornig CPU- och minnesresurshantering genom att undvika underprovisionering och överprovisionering. Dockers resurshantering fyller luckan genom att isolera containerresurser.

Skala AI-infrastruktur med Kubernetes och Docker

Containerisering är en av milstolparna i utvecklingen av skalbar infrastruktur för artificiell intelligens. Containerisering av AI-applikationen och dess beroenden i en Docker-container säkerställer konsistens genom hela utvecklings-, test- och distributionsmiljöerna.

Först måste du definiera en Dockerfile för att installera miljön. Dockerfilen är en serie instruktioner om hur man bygger en Docker-bild. Den deklarerar en basbild, de beroenden som krävs och de första inställningskommandona som gäller för din app. Följande är en grundläggande Dockerfile för en Python-maskininlärningsmodell:

 # 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"]

Om Dockerfilen är klar kan du bygga Docker-avbildningen och köra behållaren. Kör följande kommandon:

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

Distribuera den dockeriserade AI-modellen till Kubernetes

Kubernetes tillhandahåller ett brett utbud av orkestreringsfunktioner som möjliggör effektiv applikationshantering i den containeriserade infrastrukturen. Distribution av Docker-avbildningen på Kubernetes säkerställer att ett visst antal programrepliker alltid körs. Följande är ett exempel på filen deployment.yaml som du kan använda till distribuera din dockeriserade maskininlärningsmodell :

 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

Ovanstående kodavsnitt visar hur du distribuerar AI-modellen, men du måste också göra modellen externt tillgänglig. Du måste exponera den genom att definiera en Kubernetes-tjänst. Service.yaml nedan illustrerar ett exempel:

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

Använd kommandoradsverktyget kubectl för att tillämpa distributions- och tjänstekonfigurationerna:

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

Skalning med Kubernetes

Kubernetes tillhandahåller utmärkta skalningsmöjligheter till AI-miljöer, vilket maximerar resursutnyttjande och prestanda. Horisontell skalning görs genom att lägga till ytterligare behållare, och vertikal skalning innebär att man lägger till ytterligare resurser som CPU eller minne till en behållare.

Horisontell skalning

Horisontell skalning används för att skala upp antalet repliker (Pods) av ett AI-system för att hantera en högre arbetsbelastning. Processen kräver att dynamisk skalning aktiveras beroende på antalet repliker. Kommandot som används för att aktivera en sådan process är `kubectl scale`. Det specifika kommandot används för att ställa in distributionen så att den fungerar upp till maximalt fem repliker:

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

Kommandot skalar upp ml-modell-distributionen för att använda fem kopior av maskininlärningsmodellbehållaren. Systemet tillhandahåller dynamiskt fler Pods för att möta det nödvändiga antalet efteråt.

Automatisk skalning med hjälp av Horizontal Pod Autoscaler (HPA)

Kubernetes underlättar automatisk skalning med hjälp av Horizontal Pod Autoscaler (HPA). HPA justerar dynamiskt antalet repliker baserat på resursanvändning, dvs CPU eller minne, i förhållande till inställda gränser. YAML-konfigurationen som visas nedan är ett relevant exempel på en HPA som dynamiskt skalas för ml-modell-distribution som svar på CPU-användning:

 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

I den här inställningen används scaleTargetRef för att definiera den Deployment som ska skalas, dvs. ml-model-deployment. Minsta replikantalet ställs in med MinReplicas, medan det maximala replikantalet styrs med maxReplicas. Dessutom ställs CPU-användningsprocenten in med targetCPUUtilizationPercentage, dvs. till 50 %.

CPU-användning på mer än 50 % över alla Pods resulterar i att replikantalet automatiskt skalas upp till maximalt 10. Så snart CPU-användningen sjunker under den inställda procentandelen, minskar Kubernetes automatiskt replikantalet för att frigöra resurser.

Vertikal skalning

Horisontell skalning är främst för att klara mer trafik, medan vertikal skalning ger mer resurser (som CPU eller minne) till befintliga behållare. Processen är att skala upp eller ned resursbegäranden och begränsningar i Kubernetes Deployment. För att skala upp CPU- och minnesgränserna för ml-model-deployment, skulle man behöva öppna filen 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"

I denna uppdaterade konfiguration:

• begäran anger de minimiresurser som krävs för behållaren.
• limits definierar de maximala resurser som behållaren kan använda.