Eseguire la migrazione da Docker Compose a Aspire

Questa guida illustra come eseguire la migrazione di applicazioni da Docker Compose a Aspire, evidenziando le principali differenze concettuali e fornendo esempi pratici per scenari di migrazione comuni.

Comprendere le differenze

Mentre Docker Compose e Aspire potrebbe sembrare simile a prima vista, servono scopi diversi e operano a diversi livelli di astrazione.

Docker Componi vs Aspire

	Docker Comporre	Aspire
Scopo principale	Orchestrazione dei contenitori	Orchestrazione e composizione delle app in fase di sviluppo.
Ambito	Incentrato sul contenitore	Risorse multiple (contenitori, .NET progetti, risorse cloud).
Configurazione	Basato su YAML	Basato su C#, fortemente tipizzato.
Ambiente di destinazione	Qualsiasi Docker runtime	Sviluppo e distribuzione cloud.
Individuazione dei servizi	Individuazione di contenitori basata su DNS	Individuazione dei servizi integrata con variabili di ambiente.
Esperienza di sviluppo	Gestione manuale dei contenitori	Strumenti integrati, dashboard e dati di telemetria.

Per altre informazioni, vedere Docker Guida di riferimento all'API Compose to Aspire AppHost.

Principali spostamenti concettuali

Quando si esegue la migrazione da Docker Compose a Aspire, prendere in considerazione queste differenze concettuali:

• Da YAML a C#: la configurazione passa da YAML dichiarativo a codice C# imperativo e fortemente tipizzato.
• Dai contenitori alle risorse: Aspire gestisce non solo contenitori, ma .NET progetti, eseguibili, parametri, tutte come risorse.
• Dalla rete manuale all'individuazione dei servizi: Aspire configura automaticamente l'individuazione del servizio e le stringhe di connessione.
• Dalle lacune di sviluppo all'esperienza integrata: Aspire fornisce dashboard, dati di telemetria e integrazione del debug.

Per un mapping completo della Docker sintassi YAML di Compose alle Aspire chiamate API C#, vedere Docker Le informazioni di riferimento sulle API Compose to Aspire AppHost.

Collegamenti correlati:

• Docker Panoramica di Compose
• Aspire panoramica
• Aspire Panoramica dell'orchestrazione

Modelli di migrazione comuni

Questa sezione illustra scenari di migrazione pratici che probabilmente si riscontrano quando si passa da Docker Compose a Aspire. Ogni modello mostra un esempio completo di Compose Docker insieme al suo equivalente Aspire, evidenziando le differenze principali e i vantaggi della migrazione.

I modelli trattati includono:

• Applicazioni Web multiservizio con componenti front-end , API e database.
• Servizi basati su container che utilizzano immagini esistenti Docker.
• Variabili di ambiente e strategie di gestione della configurazione.
• Reti e volumi personalizzati per la persistenza dei dati e l'isolamento del servizio.

Questi esempi rappresentano i casi d'uso più comuni, ma Aspirela flessibilità consente molti altri scenari. Se il caso d'uso specifico non è trattato qui, è possibile combinare questi modelli o fare riferimento al riferimento completo all'API precedente.

Applicazione Web multiservizio

Docker Esempio di composizione:

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 equivalente:

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();

Differenze principali:

• Dipendenze del servizio: depends_on diventa WithReference() che configura anche l'individuazione del servizio.
• Variabili di ambiente: le stringhe di connessione vengono generate e inserite automaticamente.
• Contesto di compilazione: il contesto di compilazione è in grado di utilizzare Dockerfile, .NET progetti, Node.js app e altro ancora anziché solo Dockerfile compilazioni.
• Persistenza dei dati: i volumi vengono gestiti automaticamente da Aspire.

Servizi basati su contenitori

Docker Esempio di composizione:

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 equivalente:

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();

Variabili di ambiente e configurazione

Docker L'approccio Compose:

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 approccio:

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();

Differenze principali:

• Stringhe di connessione automatiche: gli URL del database e della cache vengono generati automaticamente.
• Parametri tipizzati: La configurazione esterna usa parametri fortemente tipizzati anziché la sostituzione delle variabili di ambiente.
• Individuazione dei servizi: i riferimenti configurano automaticamente gli endpoint di servizio corretti.

Reti e volumi personalizzati

Docker Esempio di composizione:

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 equivalente:

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();

Differenze principali:

• Rete semplificata: Aspire gestisce automaticamente la rete dei contenitori.
• Gestione dei volumi: i volumi denominati vengono creati e gestiti tramite il modello di risorse.
• Bind mounts: le directory host possono essere montate con WithBindMount().

Collegamenti correlati:

• Docker Specifica di Compose
• Aspire Panoramica di AppHost
• Aggiungere Dockerfile al .NET modello di app

Strategia di migrazione

La migrazione da Docker Compose a Aspire richiede un approccio sistematico. I passaggi seguenti forniscono una metodologia collaudata per lo spostamento delle applicazioni, riducendo al minimo le interruzioni e assicurando che tutti i componenti funzionino correttamente nel nuovo ambiente.

1. Valutare la configurazione corrente

Prima di eseguire la migrazione, eseguire l'inventario della Docker configurazione di Compose:

• Servizi: identificare tutti i servizi, inclusi database, cache, API e applicazioni Web.
• Dipendenze: Mappare le dipendenze del servizio dalle depends_on dichiarazioni.
• Persistenza dei dati: catalogare tutti i volumi e associare i montaggi usati per l'archiviazione dei dati.
• Variabili di ambiente: elencare tutte le variabili di configurazione e i segreti.
• Reti personalizzate: identificare eventuali requisiti e configurazioni di rete personalizzati.

2. Creare l'AppHost Aspire

Per iniziare, creare un nuovo Aspire progetto:

dotnet new aspire-apphost -o MyApp.AppHost

3. Eseguire la migrazione incrementale dei servizi

Eseguire la migrazione dei servizi uno alla volta, a partire dai servizi di supporto (database, cache) e poi dalle applicazioni.

1. Aggiungere servizi di backup come PostgreSQL, Redise altri componenti dell'infrastruttura.
2. Convertire .NET le applicazioni in riferimenti al progetto per una migliore integrazione.
3. Convertire altri contenitori usando AddContainer() per le immagini esistenti Docker .
4. Configurare le dipendenze con WithReference() per stabilire relazioni di servizio.
5. Configurare variabili di ambiente e parametri per la gestione della configurazione.

4. Gestire la migrazione dei dati

Per i dati persistenti:

• Usare WithVolume() per i volumi denominati che devono rendere persistenti i dati.
• Usare WithBindMount() per i montaggi della directory host quando è necessario l'accesso diretto ai file host.
• È consigliabile usare WithDataVolume() per la persistenza del database con la gestione automatica dei volumi.

5. Testare e convalidare

• Aspire Avviare AppHost e verificare che tutti i servizi vengano avviati correttamente.
• Controllare il dashboard per verificare l'integrità del servizio e lo stato della connettività.
• Verificare che la comunicazione tra servizi funzioni come previsto.
• Testare con le applicazioni client esistenti per garantire la compatibilità.

Collegamenti correlati:

• Docker Comporre l'elenco di controllo per la migrazione
• Creare la prima Aspire app
• Aspire panoramica dei test

Risoluzione dei problemi di migrazione

Quando si esegue la migrazione da Docker Compose a Aspire, è possibile che si verifichino alcune problematiche comuni. In questa sezione vengono fornite soluzioni ai problemi riscontrati di frequente e indicazioni su come risolvere i problemi che si verificano durante il processo di migrazione.

Problemi e soluzioni comuni

Rilevamento del servizio non è funzionante

• Assicurarsi di usare WithReference() per stabilire le dipendenze tra i servizi.
• Verificare che i servizi usino i nomi delle variabili di ambiente corretti per le connessioni.
• Esaminare il dashboard per verificare che le variabili di ambiente siano inserite correttamente.

Connessioni al database non riuscite

• Verificare che il database sia stato avviato completamente prima che i servizi dipendenti tentino di connettersi.

• Usare WaitFor() per garantire l'ordinamento corretto dell'avvio:

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

Problemi di montaggio del volume

• Utilizzare percorsi assoluti per i montaggi di bind per evitare problemi di risoluzione dei percorsi.
• Verificare che la directory host esista e disponga delle autorizzazioni appropriate prima del montaggio.
• Se possibile, prendere in considerazione l'uso di volumi nominati invece di montaggi di bind per una migliore portabilità.

Conflitti di porta

• Aspire assegna automaticamente le porte per evitare conflitti tra i servizi.
• Usare WithHttpEndpoint() per specificare porte personalizzate, se necessario per l'accesso esterno.
• Controllare la presenza di porte assegnate effettive nel dashboard durante lo sviluppo.

Collegamenti correlati:

• Docker Domande frequenti su Compose
• Runtime del contenitore non integro
• Impossibile trovare il runtime del contenitore 'podman' in WSL
• Aspire Panoramica del dashboard

Passaggi successivi

Dopo la migrazione a Aspire:

• Esplorare Aspire le integrazioni per sostituire configurazioni di contenitori personalizzate.
• Configurare i controlli di integrità per un monitoraggio migliore.
• Configurare i dati di telemetria per l'osservabilità.
• Informazioni sulle opzioni di distribuzione per gli ambienti di produzione.
• Prendere in considerazione il collaudo della propria applicazione distribuita.

Vedere anche

• Aspire panoramica
• Flusso AspiriFridays
• Aspire Panoramica dell'orchestrazione
• Docker Comporre miglioramenti nella Aspire versione 9.3
• Aggiungere Dockerfile al .NET modello di app