Aspire

Pronto per gli agenti

01

Aspire è uno strumento code-first e pronto per gli agenti per comporre, eseguire il debug e il deployment di applicazioni distribuite.

Aspire è uno strumento code-first e pronto per gli agenti per comporre, eseguire il debug e il deployment di applicazioni distribuite.

Aspire è una piattaforma open source orientata agli sviluppatori per la creazione, l'esecuzione e il deployment di app distribuite.

Aspire è un modo code-first per definire servizi, database, container e dipendenze insieme in un unico posto.

Aspire è una toolchain di orchestrazione local-first che esegue l'intera app distribuita con un solo comando.

Aspire è una piattaforma poliglotta per orchestrare app create con C#, JavaScript, Python, Java, Go e altro ancora.

Aspire è un modello applicativo con convenzioni predefinite che gestisce stringhe di connessione, porte, dipendenze e ordine di avvio.

Aspire è orientato all'osservabilità, con log, metriche, tracce e controlli di integrità integrati tramite OpenTelemetry.

Aspire è un'unica definizione di architettura che funziona in locale, in CI/CD e su Kubernetes e host cloud.

Aspire è estensibile per progettazione, con integrazioni per database, cache, servizi cloud e strumenti per sviluppatori.

Aspire è un control plane unificante in cui AppHost modella i sistemi distribuiti come codice, non come YAML o script.

Aspire è progettato per rendere i sistemi distribuiti accessibili e produttivi come una singola applicazione.

Aspire è una piattaforma code-first che porta l'intero ciclo di vita delle applicazioni distribuite nel tuo flusso di lavoro.

Aspire è una piattaforma di sviluppo open source per orchestrare interi stack applicativi insieme e in modo aperto.

Aspire è uno stack applicativo cloud-native per creare, eseguire, osservare e rilasciare app moderne fin da oggi.

Aspire è un modo per definire nel codice l'intera topologia della tua app, dai servizi e database fino a ogni dipendenza.

Aspire è una toolchain unificata per eseguire, osservare, testare e distribuire applicazioni multi-servizio.

Aspire è un livello di orchestrazione che connette i componenti dell'applicazione e ne gestisce l'esecuzione congiunta.

Aspire è un modello di sviluppo local-first che rispecchia gli ambienti di produzione senza modificare la tua app.

Aspire è un modo per avviare in locale l'intero sistema distribuito, con le sue dipendenze, in un solo comando.

Aspire è una piattaforma che elimina gli attriti dell'infrastruttura, così puoi dedicare più tempo a scrivere codice applicativo.

Aspire è modulare, estensibile e poliglotta, così i tuoi linguaggi, framework e la tua infrastruttura restano tuoi.

Aspire è un livello di osservabilità con log, metriche, tracce e controlli di integrità integrati e pronti fin dall'inizio.

Aspire è indipendente dall'ambiente: funziona in locale e si distribuisce su cloud, Kubernetes o sistemi on-premises.

Aspire è infrastruttura come codice per la topologia della tua applicazione, espressa nel linguaggio di programmazione che usi.

Aspire è orchestrazione, osservabilità e deployment uniti nel codice, senza dover mettere insieme più strumenti.

Aspire è un'astrazione pensata per gli sviluppatori che rende i sistemi distribuiti più facili da creare, sottoporre a debug e gestire.

Aspire è l'intera architettura della tua app, definita nel codice e pronta a essere eseguita in locale o pubblicata per il deployment.

Aspire è una piattaforma orientata agli sviluppatori che offre alle applicazioni distribuite un modello e un flusso di lavoro coerenti.

Aspire è orchestrazione, osservabilità e deployment integrati direttamente nel tuo flusso di lavoro quotidiano di sviluppo.

Dichiarazione 1 di 29. Pronto per gli agenti. Aspire è uno strumento code-first e pronto per gli agenti per comporre, eseguire il debug e il deployment di applicazioni distribuite.

Scopri di più

Perché gli sviluppatori scelgono Aspire

Controllo incentrato sul codice

Definisci lo stack nel codice—type-safe e leggibile. Esegui in locale, distribuisci ovunque senza cambiare architettura.

Modulare ed estendibile

Orchestra frontend, API, container e database senza riscritture. Estendi Aspire per adattarlo al tuo stack—distribuisci ovunque.

Osservabilità fin dall'inizio

OpenTelemetry integrato fornisce log, tracce e health check automaticamente—debug più rapido senza setup.

Deployment flessibili

Distribuisci ovunque—Kubernetes, cloud o on-prem. Aspire si adatta per deployment coerenti senza riscritture.

Definisci il tuo stack nel codice

Aspire è modulare, componibile ed estendibile. Configura relazioni, opzioni di deployment e flag di sviluppo in un unico posto. Scopri di più su AppHost.

Crea il tuo AppHost

Attiva/disattiva funzionalità per vedere come Aspire definisce parti dello stack.

C#TypeScript

Front endDatabaseServizio APIContainerOpzioni di distribuzione

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// This would be a rather boring AppHost ☹️...
// Toggle the options above to see what an AppHost might look like.
// For example, select "Front end" to add a frontend service.

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT");

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT");

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT");

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT");

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj");

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj");

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres);

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres);

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj");

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj");

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddPostgres("db")
    .AddDatabase("appdata");

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080);

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add frontend service
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api)
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api)
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres)
    .WaitFor(postgres)
    .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api)
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres)
    .WaitFor(postgres)
    .PublishAsAzureContainerApp();

// Add frontend service and reference the API
var frontend = builder.AddViteApp("frontend", "../frontend")
    .WithHttpEndpoint(env: "PORT")
    .WithReference(api)
    .WithNpmPackageInstallation()
    .PublishAsDockerFile();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .PublishAsAzureContainerApp();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add API service
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .PublishAsAzureContainerApp();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres)
    .WaitFor(postgres)
    .PublishAsAzureContainerApp();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add database
var postgres = builder.AddAzurePostgresFlexibleServer("db")
    .AddDatabase("appdata")
    .WithDataVolume()
    .RunAsContainer();

// Add API service and reference the database
var api = builder.AddProject("api", "../api/ApiService.csproj")
    .WithReference(postgres)
    .WaitFor(postgres)
    .PublishAsAzureContainerApp();

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

AppHost.cs

var builder = DistributedApplication.CreateBuilder(args);

// Add custom container
var customContainer = builder.AddContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .WithHttpEndpoint(targetPort: 8080)
    .PublishAsKubernetes();

builder.Build().Run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// This would be a rather boring AppHost ☹️...
// Toggle the options above to see what an AppHost might look like.
// For example, select "Front end" to add a frontend service.

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" });

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" });

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" });

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api);

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" });

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api);

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres);

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api);

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres);

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api);

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" });

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres);

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addPostgres("db")
    .addDatabase("appdata");

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres);

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 });

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withNpmPackageInstallation()
    .publishAsDockerFile();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withNpmPackageInstallation()
    .publishAsDockerFile();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withNpmPackageInstallation()
    .publishAsDockerFile();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add Vite frontend
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withNpmPackageInstallation()
    .publishAsDockerFile();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .publishAsAzureContainerApp();

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api)
    .withNpmPackageInstallation()
    .publishAsDockerFile();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .publishAsAzureContainerApp();

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api)
    .withNpmPackageInstallation()
    .publishAsDockerFile();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres)
    .waitFor(postgres)
    .publishAsAzureContainerApp();

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api)
    .withNpmPackageInstallation()
    .publishAsDockerFile();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres)
    .waitFor(postgres)
    .publishAsAzureContainerApp();

// Add Vite frontend and reference the API
const frontend = await builder
    .addViteApp("frontend", "./frontend")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(api)
    .withNpmPackageInstallation()
    .publishAsDockerFile();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .publishAsAzureContainerApp();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add Express API
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .publishAsAzureContainerApp();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres)
    .waitFor(postgres)
    .publishAsAzureContainerApp();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add database
const postgres = await builder
    .addAzurePostgresFlexibleServer("db")
    .addDatabase("appdata")
    .withDataVolume()
    .runAsContainer();

// Add Express API and reference the database
const api = await builder
    .addNodeApp("api", "./api", "src/index.ts")
    .withHttpEndpoint({ env: "PORT" })
    .withReference(postgres)
    .waitFor(postgres)
    .publishAsAzureContainerApp();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

apphost.mts

import { createBuilder } from './.aspire/modules/aspire.mjs';

const builder = await createBuilder();

// Add custom container
const customContainer = await builder
    .addContainer("mycustomcontainer", "myregistry/myapp", "latest")
    .withHttpEndpoint({ targetPort: 8080 })
    .publishAsKubernetes();

await builder.build().run();

Supporto multilinguaggio e poliglotta

Costruito per il tuo stack, Aspire orchestra applicazioni in C#, Java, Python, JavaScript, TypeScript, Go e altro—usa i linguaggi che preferisci. Scopri come modellare le tue app.

GoPythonJavaScriptTypeScriptJavaC#And more...

Aspire supporta molti linguaggi e framework e ti permette di sviluppare con i tuoi preferiti mentre orchestra tutto.

Locale-first, pronta per la produzione

Pensata per lo sviluppo locale, Aspire replica la produzione sulla tua macchina eliminando il classico “sul mio PC funziona”. Scopri deployment e topologia.

LocaleTestProd

Sviluppo locale con servizi containerizzati

Avvia e termina ambienti di staging completi per i test

Servizi cloud di produzione — nessuna modifica al codice

aspire run

aspire deploy -e test

aspire deploy

Redis

AWS ElastiCache

Redis

Shortlived container

Redis

Local container

PostgreSQL

Azure Database for PostgreSQL

PostgreSQL

Staged DB

PostgreSQL

Local container

Frontend

Azure Static Web Apps

Frontend

Dev tunnel

Frontend

Local process

API

Azure Container Apps

API

Staging environment

API

Local process

Stesso modello — ambienti diversi

Usa la CLI di Aspire per avviare tutto localmente o generare artefatti di deployment in CI/CD. Inizia e crea la tua prima app Aspire.

Sviluppo locale

aspire run

• Usa runtime container locale
• Dashboard su localhost
• Usa secret, volumi e config di sviluppo

Deployment in produzione

aspire deploy

• Stessa struttura app, deploy ovunque
• Servizi cloud gestiti o infrastruttura propria
• Integrazione fluida con pipeline CI/CD

Dashboard OpenTelemetry per sviluppatori

Monitora log, metriche e tracce in tempo reale con il dashboard OpenTelemetry integrato nel tuo flusso di lavoro. Scopri il dashboard.

Grafo delle risorse

Esplora le integrazioni

Multi-cloud, integrazioni senza limiti — Collega Aspire ad Azure, AWS o alla tua infrastruttura. Sfrutta un ecosistema di integrazioni per qualunque stack. Scopri tutte le integrazioni.

Testimonianze degli utenti

Non solo la nostra parola! Dagli indie hacker alle enterprise—gli sviluppatori costruiscono più veloce e distribuiscono con fiducia con Aspire. Unisciti alla community Aspire.

SP

Aspire lets developers be developers again.

Steven Price (Software Engineering Manager, Iceland Foods)

RH

I had someone start on a Monday morning and they were contributing code by lunch.

Russ Harding (VP Engineering, EQengineered)

MJ

I was surprised by how quickly Aspire got me from idea to running services.

Milan Jovanović (Educator & Content Creator, MJ Tech)

NU

I've never wanted to commit to a Microsoft technology this much.

Nk54 (Reddit User)

CT

Hit F5 to begin — skip the setup boss fight, ship code faster.

Craig Taylor (Principal Architect, Xbox Live)

SK

Aspire was easy to integrate with our existing container orchestration.

Sean Killeen (VP Innovation, SCT Software)

DC

OpenTelemetry out-of-the-box in the Aspire dashboard is a game changer for observability!

Dan Clarke (Developer & Podcaster, Everstack)

Pronto al decollo?

Installa la CLI di Aspire e poi esplora la documentazione per imparare a modellare, eseguire e distribuire le tue applicazioni.

Ottieni AspireInstalla Aspire e accelera il tuo workflow.

Vedi documentazioneImpara a modellare, eseguire e distribuire app con Aspire.