Migrera från Docker Skriv till Aspire

Den här guiden hjälper dig att förstå hur du migrerar program från Docker Compose till Aspire, lyfter fram de viktigaste konceptuella skillnaderna och ger praktiska exempel för vanliga migreringsscenarier.

Förstå skillnaderna

Även om Docker Compose och Aspire kan verka liknande vid första anblicken, tjänar de olika syften och fungerar på olika abstraktionsnivåer.

Docker Skriv jämfört med Aspire

	Docker Komponera	Aspire
Primärt syfte	Orkestrering av containrar	Orkestrering och applikationssammansättning under utveckling.
Omfattning	Containerfokuserat	Flera resurser (containrar, .NET projekt, molnresurser).
Konfiguration	YAML-baserad	C#-baserad, starkt typad.
Målmiljö	Vilken Docker körtid som helst	Utveckling och molndistribution.
Tjänstidentifiering	DNS-baserad containeridentifiering	Inbyggd tjänstidentifiering med miljövariabler.
Utvecklingsupplevelse	Manuell containerhantering	Integrerade verktyg, instrumentpaneler och telemetri.

Mer information finns i Docker Skapa till Aspire AppHost API-referens.

Viktiga konceptuella skift

När du migrerar från Docker Compose till Aspirebör du tänka på följande begreppsmässiga skillnader:

• Från YAML till C#: Konfigurationen flyttas från deklarativ YAML till imperativ, starkt skriven C#-kod.
• Från containrar till resurser: Aspire hanterar inte bara containrar, utan .NET projekt, körbara filer, parametrar, alla som resurser.
• Från manuell nätverksanslutning till tjänstidentifiering: Aspire konfigurerar automatiskt tjänstidentifiering och anslutningssträngar.
• Från utvecklingsluckor till integrerad upplevelse: Aspire tillhandahåller instrumentpanel, telemetri och felsökningsintegrering.

En omfattande referenskarta mellan Docker Compose YAML-syntax och Aspire C# API-anrop finns i Docker Compose till Aspire AppHost API-referens.

Relaterade länkar:

• Docker Skapa översikt
• Aspire överblick
• Aspire översikt över orkestrering

Vanliga migreringsmönster

Det här avsnittet visar praktiska migreringsscenarier som du troligen kommer att stöta på när du flyttar från Docker Compose till Aspire. Varje mönster visar ett komplett Docker Compose-exempel tillsammans med dess Aspire motsvarighet, som belyser de viktigaste skillnaderna och fördelarna med migreringen.

De mönster som omfattas är:

• Webbprogram med flera tjänster med klientdels-, API- och databaskomponenter.
• Containerbaserade tjänster med befintliga Docker bilder.
• Miljövariabler och strategier för konfigurationshantering .
• Anpassade nätverk och volymer för datapersistence och tjänstisolering.

De här exemplen representerar de vanligaste användningsfallen, men Aspireflexibiliteten tillåter många andra scenarier. Om ditt specifika användningsfall inte beskrivs här kan du kombinera dessa mönster eller referera till den omfattande API-referensen ovan.

Webbprogram med flera tjänster

Docker Skriv exempel:

version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - api
    environment:
      - API_URL=http://api:5000

  api:
    build: ./api
    ports:
      - "5000:5000"
    depends_on:
      - database
    environment:
      - ConnectionStrings__DefaultConnection=Host=database;Database=myapp;Username=postgres;Password=secret

  database:
    image: postgres:15
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=secret
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Aspire ekvivalent:

var builder = DistributedApplication.CreateBuilder(args);

// Add the database
var database = builder.AddPostgres("postgres")
    .WithEnvironment("POSTGRES_DB", "myapp")
    .AddDatabase("myapp");

// Add the API project
var api = builder.AddProject<Projects.MyApp_Api>("api")
    .WithReference(database);

// Add the frontend project  
var frontend = builder.AddProject<Projects.MyApp_Frontend>("frontend")
    .WithReference(api);

builder.Build().Run();

Viktiga skillnader:

• Tjänstberoenden: depends_on blir WithReference() som också konfigurerar tjänstidentifiering.
• Miljövariabler: Anslutningssträngar genereras och matas in automatiskt.
• Byggkontext: Byggkontexten kan använda Dockerfiles, .NET projekt, Node.js appar med mera i stället för att bara använda builds.
• Datapersistence: Volymer hanteras automatiskt av Aspire.

Containerbaserade tjänster

Docker Skriv exempel:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - redis
      - postgres

  redis:
    image: redis:7
    ports:
      - "6379:6379"

  postgres:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Aspire ekvivalent:

var builder = DistributedApplication.CreateBuilder(args);

// Add backing services
var cache = builder.AddRedis("redis");
var database = builder.AddPostgres("postgres", password: "secret")
    .AddDatabase("main");

// Add the containerized web application
var web = builder.AddContainer("web", "myapp:latest")
    .WithHttpEndpoint(port: 8080, targetPort: 8080)
    .WithReference(cache)
    .WithReference(database);

builder.Build().Run();

Miljövariabler och konfiguration

Docker Kompositionsmetod:

services:
  app:
    image: myapp:latest
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
      - REDIS_URL=redis://cache:6379
      - API_KEY=${API_KEY}
      - LOG_LEVEL=info

Aspire metod:

var builder = DistributedApplication.CreateBuilder(args);

// Add external parameter
var apiKey = builder.AddParameter("apiKey", secret: true);

var database = builder.AddPostgres("db")
    .AddDatabase("myapp");
    
var cache = builder.AddRedis("cache");

var app = builder.AddContainer("app", "myapp:latest")
    .WithReference(database)      // Automatically sets DATABASE_URL
    .WithReference(cache)         // Automatically sets REDIS_URL  
    .WithEnvironment("API_KEY", apiKey)
    .WithEnvironment("LOG_LEVEL", "info");

builder.Build().Run();

Viktiga skillnader:

• Automatiska anslutningssträngar: Databas- och cache-URL:er genereras automatiskt.
• Typade parametrar: Extern konfiguration använder starkt typade parametrar i stället för miljövariabelersättning.
• Tjänstidentifiering: Referenser konfigurerar automatiskt rätt tjänstslutpunkter.

Anpassade nätverk och volymer

Docker Skriv exempel:

version: '3.8'
services:
  app:
    image: myapp:latest
    volumes:
      - app_data:/data
      - ./config:/app/config:ro
    networks:
      - backend

  worker:
    image: myworker:latest
    volumes:
      - app_data:/shared
    networks:
      - backend

networks:
  backend:

volumes:
  app_data:

Aspire ekvivalent:

var builder = DistributedApplication.CreateBuilder(args);

// Create a named volume
var appData = builder.AddVolume("app-data");

var app = builder.AddContainer("app", "myapp:latest")
    .WithVolume(appData, "/data")
    .WithBindMount("./config", "/app/config", isReadOnly: true);

var worker = builder.AddContainer("worker", "myworker:latest")
    .WithVolume(appData, "/shared");

builder.Build().Run();

Viktiga skillnader:

• Förenklat nätverk: Aspire hanterar automatiskt containernätverk.
• Volymhantering: Namngivna volymer skapas och hanteras via resursmodellen.
• Bind-mounts: Man kan montera värdkataloger med WithBindMount().

Relaterade länkar:

• Docker Skriv specifikation
• Aspire Översikt över AppHost
• Lägga till Dockerfiles i din .NET appmodell

Migreringsstrategi

Att migrera från Docker Compose till Aspire kräver en systematisk metod. Följande steg ger en beprövad metod för att flytta dina program samtidigt som avbrott minimeras och alla komponenter fungerar korrekt i den nya miljön.

1. Utvärdera din aktuella konfiguration

Innan du migrerar bör du inventera din Docker Compose-konfiguration:

• Tjänster: Identifiera alla tjänster, inklusive databaser, cacheminnen, API:er och webbprogram.
• Beroenden: Mappa ut tjänstberoenden från depends_on deklarationer.
• Datapersistence: Katalogisera alla volymer och bindningsmonteringar som används för datalagring.
• Miljövariabler: Lista alla konfigurationsvariabler och hemligheter.
• Anpassade nätverk: Identifiera eventuella anpassade nätverkskrav och konfigurationer.

2. Skapa Aspire AppHost

Börja med att skapa ett nytt Aspire projekt:

dotnet new aspire-apphost -o MyApp.AppHost

3. Migrera tjänster stegvis

Migrera tjänster en i taget, från och med säkerhetskopieringstjänster (databaser, cacheminnen) och sedan program:

1. Lägg till säkerhetskopieringstjänster som PostgreSQL, Redisoch andra infrastrukturkomponenter.
2. Konvertera .NET program till projektreferenser för bättre integrering.
3. Konvertera andra containrar genom att använda AddContainer() för befintliga Docker avbildningar.
4. Konfigurera beroenden med WithReference() för att upprätta tjänstrelationer.
5. Konfigurera miljövariabler och parametrar för konfigurationshantering.

4. Hantera datamigrering

För beständiga data:

• Använd WithVolume() för namngivna volymer som behöver spara data.
• Använd WithBindMount() för värdkatalogmonteringar när du behöver direkt åtkomst till värdfiler.
• Överväg att använda WithDataVolume() för databaspersistence med automatisk volymhantering.

5. Testa och validera

• Aspire Starta AppHost och kontrollera att alla tjänster startas korrekt.
• Kontrollera instrumentpanelen för att bekräfta tjänstens hälsotillstånd och anslutningsstatus.
• Kontrollera att kommunikation mellan tjänster fungerar som förväntat.
• Testa med dina befintliga klientprogram för att säkerställa kompatibilitet.

Relaterade länkar:

• Docker Skriv checklista för migrering
• Skapa din första Aspire app
• Aspire testöversikt

Felsökning av migrering

När du migrerar från Docker Compose till Aspirekan du stöta på några vanliga utmaningar. Det här avsnittet innehåller lösningar på vanliga problem och vägledning om hur du felsöker problem som uppstår under migreringsprocessen.

Vanliga problem och lösningar

Tjänstidentifieringen fungerar inte

• Se till att du använder WithReference() för att upprätta beroenden mellan tjänster.
• Kontrollera att tjänsterna använder rätt miljövariabelnamn för anslutningar.
• Granska instrumentpanelen för att kontrollera att miljövariablerna matas in korrekt.

Databasanslutningar misslyckas

• Kontrollera att databasen är helt igång innan beroende tjänster försöker ansluta.

• Använd WaitFor() för att säkerställa korrekt startordning:

  var api = builder.AddProject<Projects.Api>("api")
      .WithReference(database)
      .WaitFor(database);
  

Problem med volymmontering

• Använd absoluta sökvägar för bindningsmonteringar för att undvika problem med sökvägslösning.
• Kontrollera att värdkatalogen finns och har rätt behörigheter innan du monterar den.
• Överväg att använda namngivna volymer istället för bind mounts där det är möjligt för bättre portabilitet.

Portkonflikter

• Aspire tilldelar automatiskt portar för att undvika konflikter mellan tjänster.
• Använd WithHttpEndpoint() för att ange anpassade portar om det behövs för extern åtkomst.
• Kontrollera instrumentpanelen för faktiska tilldelade portar under utvecklingen.

Relaterade länkar:

• Docker Skriv vanliga frågor och svar
• Containerkörningen är ohälsosam
• Det gick inte att hitta containerkörningen "podman" i WSL
• Aspire översikt över instrumentpanelen

Nästa steg

Efter migreringen till Aspire:

• Utforska Aspire integreringar för att ersätta anpassade containerkonfigurationer.
• Konfigurera hälsokontroller för bättre övervakning.
• Konfigurera telemetri för observerbarhet.
• Läs mer om distributionsalternativ för produktionsmiljöer.
• Överväg att testa ditt distribuerade program.

Se även

• Aspire överblick
• AspiriFridays-ström
• Aspire översikt över orkestrering
• Docker Skapa förbättringar i Aspire 9.3
• Lägga till Dockerfiles i din .NET appmodell