.NET .NET Aspire formátu manifestu pro tvůrce nástrojů pro nasazení

Článek
12/14/2024

V tomto článku se dozvíte o formátu manifestu .NET.NET Aspire. Tento článek slouží jako referenční příručka pro tvůrce nástrojů pro nasazení a pomáhá při vytváření nástrojů pro nasazování .NET.NET Aspire projektů na konkrétních hostitelských platformách, ať už místně nebo v cloudu.

.NET .NET Aspire zjednodušuje místní vývojové prostředí tím, že pomáhá spravovat vzájemné závislosti mezi integracemi aplikací. Pro zjednodušení nasazení aplikací můžou projekty .NET Aspire generovat manifest všech prostředků definovaných jako JSON formátovaný soubor.

Vygenerování manifestu

K vygenerování manifestu se vyžaduje platný projekt .NET.NET Aspire. Začněte vytvořením .NET.NET Aspire projektu pomocí šablony aspire-starter.NET:

dotnet new aspire-starter --use-redis-cache `
    -o AspireApp && `
    cd AspireApp

Generování manifestu se dosahuje spuštěním dotnet build se zvláštním cílem:

dotnet run --project AspireApp.AppHost\AspireApp.AppHost.csproj `
    --publisher manifest `
    --output-path ../aspire-manifest.json

Spropitné

--output-path podporuje relativní cesty. Předchozí příkaz používá ../aspire-manifest.json k umístění souboru manifestu do kořenového adresáře projektu.

Další informace naleznete v tématu dotnet run. Předchozí příkaz vytvoří následující výstup:

Building...
info: Aspire.Hosting.Publishing.ManifestPublisher[0]
      Published manifest to: .\AspireApp.AppHost\aspire-manifest.json

Vygenerovaný soubor je manifest .NET.NET Aspire a používá ho nástroje k podpoře nasazení do cílových cloudových prostředí.

Poznámka

Manifest můžete také vygenerovat jako součást spouštěcího profilu. Zvažte následující launchSettings.json:

{
  "$schema": "http://json.schemastore.org/launchsettings.json",
  "profiles": {
    "generate-manifest": {
      "commandName": "Project",
      "launchBrowser": false,
      "dotnetRunMessages": true,
      "commandLineArgs": "--publisher manifest --output-path aspire-manifest.json"
    }
  }
}

Základní formát manifestu

Publikování manifestu z výchozí počáteční šablony pro .NET Aspire vytvoří následující výstup JSON:

{
  "resources": {
    "cache": {
      "type": "container.v0",
      "connectionString": "{cache.bindings.tcp.host}:{cache.bindings.tcp.port}",
      "image": "redis:7.2.4",
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 6379
        }
      }
    },
    "apiservice": {
      "type": "project.v0",
      "path": "../AspireApp.ApiService/AspireApp.ApiService.csproj",
      "env": {
        "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EXCEPTION_LOG_ATTRIBUTES": "true",
        "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EVENT_LOG_ATTRIBUTES": "true"
      },
      "bindings": {
        "http": {
          "scheme": "http",
          "protocol": "tcp",
          "transport": "http"
        },
        "https": {
          "scheme": "https",
          "protocol": "tcp",
          "transport": "http"
        }
      }
    },
    "webfrontend": {
      "type": "project.v0",
      "path": "../AspireApp.Web/AspireApp.Web.csproj",
      "env": {
        "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EXCEPTION_LOG_ATTRIBUTES": "true",
        "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EVENT_LOG_ATTRIBUTES": "true",
        "ConnectionStrings__cache": "{cache.connectionString}",
        "services__apiservice__0": "{apiservice.bindings.http.url}",
        "services__apiservice__1": "{apiservice.bindings.https.url}"
      },
      "bindings": {
        "http": {
          "scheme": "http",
          "protocol": "tcp",
          "transport": "http"
        },
        "https": {
          "scheme": "https",
          "protocol": "tcp",
          "transport": "http"
        }
      }
    }
  }
}

Formát manifestu JSON se skládá z jednoho objektu nazývaného resources, který obsahuje vlastnost pro každý prostředek zadaný v Program.cs (argument name pro každý název se používá jako vlastnost pro každý podřízený objekt prostředku v JSON).

Připojovací řetězec a odkazy na vazby

V předchozím příkladu existují dva zdroje projektu a jeden Redis prostředek mezipaměti. Webová závisí na prostředcích () služby apiservice api service (projekt ).

Tato závislost je známá, protože proměnné prostředí pro webfrontend obsahují zástupné symboly, které odkazují na dva další prostředky:

"env": {
  // ... other environment variables omitted for clarity
  "ConnectionStrings__cache": "{cache.connectionString}",
  "services__apiservice__0": "{apiservice.bindings.http.url}",
  "services__apiservice__1": "{apiservice.bindings.https.url}"
},

Na prostředek apiservice odkazuje webfrontend pomocí WithReference(apiservice) volání v souboru Program.cs hostitele aplikace a redis se odkazuje pomocí WithReference(cache)volání:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");

var apiService = builder.AddProject<Projects.AspireApp_ApiService>("apiservice");

builder.AddProject<Projects.AspireApp_Web>("webfrontend")
    .WithReference(cache)
    .WithReference(apiService);

builder.Build().Run();

Odkazy mezi typy zdrojů projektu mají za následek zjišťování služby proměnné vložené do odkazujícího projektu. Odkazy na dobře známé typy odkazů, jako je Redis výsledek vkládání připojovacích řetězců.

Další informace o tom, jak fungují prostředky v modelu aplikace a odkazy mezi nimi, najdete v přehledu orchestrace .NET.NET Aspire.

Struktura zástupného řetězce

Zástupné řetězce odkazují na strukturu manifestu .NET.NET Aspire:

Poslední segment zástupného řetězce (url v tomto případě) vygeneruje nástroj, který manifest zpracovává. V zástupném řetězci je možné použít několik přípon:

connectionString: Pro dobře známé typy prostředků, jako je Redis. Nástroje pro nasazení přeloží prostředek v nejvhodnější infrastruktuře pro cílové cloudové prostředí a pak vytvoří .NET.NET Aspire kompatibilní připojovací řetězec, který bude používat spotřebovává aplikace. V container.v0 zdrojích může být pole connectionString přítomno a explicitně zadáno. Jde o podporu scénářů, kdy se na typ prostředku kontejneru odkazuje pomocí rozšíření WithReference, ale chcete ho explicitně hostovat jako kontejner.
url: Pro odkazy typu service-to-service, kde je vyžadována správně formátovaná adresa URL. Nástroj pro nasazení vytvoří url na základě schématu, protokolu a přenosu definovaného v manifestu a základní topologii výpočetních/síťových prostředků, která byla nasazena.
host: Segment hostitele adresy URL.
port: Segment portu adresy URL.

Typy prostředků

Každý zdroj má type pole. Když nástroj pro nasazení přečte manifest, měl by přečíst typ a ověřit, jestli může manifest správně zpracovat. Během období .NET.NET Aspire preview mají všechny typy prostředků příponu v0, která označuje, že se můžou změnit. Vzhledem k tomu, že .NET.NET Aspire přístupy k vydání přípony v1 se použijí k označení, že struktura manifestu pro tento typ prostředku by měla být považována za stabilní (následné aktualizace odpovídajícím způsobem zvýší číslo verze).

Běžná pole zdrojů

Pole type je jediné pole, které je společné pro všechny typy zdrojů, ale project.v0, container.v0a executable.v0 typy zdrojů také sdílejí env a bindings pole.

Poznámka

Typ prostředku executable.v0 není v manifestu plně implementovaný kvůli nedostatku nástrojů ve scénářích nasazení. Další informace o kontejnerizaci spustitelných souborů naleznete v tématu Dockerfile typy prostředků.

Typ pole env je mapování základního klíče/hodnoty, kde hodnoty můžou obsahovat zástupné řetězce.

Vazby jsou zadány v poli bindings s každou vazbou obsaženou v jejím vlastním poli pod objektem bindingsJSON. Pole vynechaná manifestem .NET.NET Aspire v uzlu bindings zahrnují:

scheme: Jedna z následujících hodnot tcp, udp, httpnebo https.
protocol: Jedna z následujících hodnot tcp nebo udp
transport: Stejné jako scheme, ale používá se k nejednoznačnosti mezi http a http2.
containerPort: Nepovinný, pokud je vynechán výchozí hodnota portu 80.

Pole `inputs`

Některé zdroje generují pole inputs. Toto pole slouží k zadání vstupních parametrů pro prostředek. Pole inputs je objekt JSON, kde každá vlastnost je vstupním parametrem, který se používá v rozlišení struktury zástupného symbolu. Prostředky, které mají connectionString, například můžou použít pole inputs k určení password připojovacího řetězce:

"connectionString": "Host={<resourceName>.bindings.tcp.host};Port={<resourceName>.bindings.tcp.port};Username=admin;Password={<resourceName>.inputs.password};"

Zástupný symbol připojovacího řetězce odkazuje na vstupní parametr password z pole inputs:

"inputs": {
  "password": {
    "type": "string",
    "secret": true,
    "default": {
      "generate": {
        "minLength": 10
      }
    }
  }
}

Předchozí fragment kódu JSON zobrazuje pole inputs zdroje, který má pole connectionString. Vstupní parametr password je typ řetězce a je označený jako tajný kód. Pole default slouží k zadání výchozí hodnoty vstupního parametru. V tomto případě se výchozí hodnota vygeneruje pomocí pole generate s náhodným řetězcem minimální délky.

Předdefinované prostředky

Následující tabulka obsahuje seznam typů prostředků, které jsou explicitně generovány .NET Aspire a rozšířeními vyvinutými týmem .NET Aspire:

Typy prostředků nezávislé na cloudu

Tyto prostředky jsou k dispozici v 📦Aspire. Hostování balíčku NuGet

Využití modelu aplikace	Typ prostředku manifestu	Odkaz na nadpis
AddContainer	`container.v0`	typ prostředku kontejneru
`PublishAsDockerFile`	`dockerfile.v0`	Dockerfile typy prostředků
AddDatabase	`value.v0`	MongoDB Server typy prostředků
AddMongoDB	`container.v0`	MongoDB typy prostředků
AddDatabase	`value.v0`	MySQL Server typy prostředků
AddMySql	`container.v0`	MySQL typy prostředků
AddDatabase	`value.v0`	Postgres typy prostředků
AddPostgres	`container.v0`	Postgres typy prostředků
AddProject	`project.v0`	typ zdroje projektu
AddRabbitMQ	`container.v0`	RabbitMQ typy prostředků
AddRedis	`container.v0`	Redis typ prostředku
AddDatabase	`value.v0`	SQL Server typy prostředků
AddSqlServer	`container.v0`	SQL Server typy prostředků

Typ zdroje projektu

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);
var apiservice = builder.AddProject<Projects.AspireApp_ApiService>("apiservice");

Příklad manifestu:

"apiservice": {
  "type": "project.v0",
  "path": "../AspireApp.ApiService/AspireApp.ApiService.csproj",
  "env": {
    "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EXCEPTION_LOG_ATTRIBUTES": "true",
    "OTEL_DOTNET_EXPERIMENTAL_OTLP_EMIT_EVENT_LOG_ATTRIBUTES": "true"
  },
  "bindings": {
    "http": {
      "scheme": "http",
      "protocol": "tcp",
      "transport": "http"
    },
    "https": {
      "scheme": "https",
      "protocol": "tcp",
      "transport": "http"
    }
  }
}

Typ prostředku kontejneru

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddContainer("mycontainer", "myimage")
       .WithEnvironment("LOG_LEVEL", "WARN")
       .WithHttpEndpoint(3000);

Příklad manifestu:

{
  "resources": {
    "mycontainer": {
      "type": "container.v0",
      "image": "myimage:latest",
      "env": {
        "LOG_LEVEL": "WARN"
      },
      "bindings": {
        "http": {
          "scheme": "http",
          "protocol": "tcp",
          "transport": "http",
          "containerPort": 3000
        }
      }
    }
  }
}

typy prostředků Dockerfile

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddNodeApp("nodeapp", "../nodeapp/app.js")
       .WithHttpEndpoint(hostPort: 5031, env: "PORT")
       .PublishAsDockerFile();

Spropitné

K vygenerování typu prostředku PublishAsDockerFile v manifestu se vyžaduje volání Dockerfile a tato metoda rozšíření je k dispozici pouze u typu ExecutableResource.

Příklad manifestu:

{
  "resources": {
    "nodeapp": {
      "type": "dockerfile.v0",
      "path": "../nodeapp/Dockerfile",
      "context": "../nodeapp",
      "env": {
        "NODE_ENV": "development",
        "PORT": "{nodeapp.bindings.http.port}"
      },
      "bindings": {
        "http": {
          "scheme": "http",
          "protocol": "tcp",
          "transport": "http",
          "containerPort": 5031
        }
      }
    }
  }
}

typy prostředků Postgres

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddPostgres("postgres1")
       .AddDatabase("shipping");

Příklad manifestu:

{
  "resources": {
    "postgres1": {
      "type": "container.v0",
      "connectionString": "Host={postgres1.bindings.tcp.host};Port={postgres1.bindings.tcp.port};Username=postgres;Password={postgres1.inputs.password}",
      "image": "postgres:16.2",
      "env": {
        "POSTGRES_HOST_AUTH_METHOD": "scram-sha-256",
        "POSTGRES_INITDB_ARGS": "--auth-host=scram-sha-256 --auth-local=scram-sha-256",
        "POSTGRES_PASSWORD": "{postgres1.inputs.password}"
      },
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 5432
        }
      },
      "inputs": {
        "password": {
          "type": "string",
          "secret": true,
          "default": {
            "generate": {
              "minLength": 10
            }
          }
        }
      }
    },
    "shipping": {
      "type": "value.v0",
      "connectionString": "{postgres1.connectionString};Database=shipping"
    }
  }
}

typy prostředků RabbitMQ

RabbitMQ se modeluje jako prostředek kontejneru container.v0. Následující ukázka ukazuje, jak se přidají do modelu aplikace.

var builder = DistributedApplication.CreateBuilder(args);

builder.AddRabbitMQ("rabbitmq1");

Předchozí kód vytvoří následující manifest:

{
  "resources": {
    "rabbitmq1": {
      "type": "container.v0",
      "connectionString": "amqp://guest:{rabbitmq1.inputs.password}@{rabbitmq1.bindings.tcp.host}:{rabbitmq1.bindings.tcp.port}",
      "image": "rabbitmq:3",
      "env": {
        "RABBITMQ_DEFAULT_USER": "guest",
        "RABBITMQ_DEFAULT_PASS": "{rabbitmq1.inputs.password}"
      },
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 5672
        }
      },
      "inputs": {
        "password": {
          "type": "string",
          "secret": true,
          "default": {
            "generate": {
              "minLength": 10
            }
          }
        }
      }
    }
  }
}

typ prostředku Redis

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddRedis("redis1");

Příklad manifestu:

{
  "resources": {
    "redis1": {
      "type": "container.v0",
      "connectionString": "{redis1.bindings.tcp.host}:{redis1.bindings.tcp.port}",
      "image": "redis:7.2.4",
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 6379
        }
      }
    }
  }
}

typy prostředků SQL Server

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddSqlServer("sql1")
       .AddDatabase("shipping");

Příklad manifestu:

{
  "resources": {
    "sql1": {
      "type": "container.v0",
      "connectionString": "Server={sql1.bindings.tcp.host},{sql1.bindings.tcp.port};User ID=sa;Password={sql1.inputs.password};TrustServerCertificate=true",
      "image": "mcr.microsoft.com/mssql/server:2022-latest",
      "env": {
        "ACCEPT_EULA": "Y",
        "MSSQL_SA_PASSWORD": "{sql1.inputs.password}"
      },
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 1433
        }
      },
      "inputs": {
        "password": {
          "type": "string",
          "secret": true,
          "default": {
            "generate": {
              "minLength": 10
            }
          }
        }
      }
    },
    "shipping": {
      "type": "value.v0",
      "connectionString": "{sql1.connectionString};Database=shipping"
    }
  }
}

typy prostředků MongoDB

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddMongoDB("mongodb1")
       .AddDatabase("shipping");

Příklad manifestu:

{
  "resources": {
    "mongodb1": {
      "type": "container.v0",
      "connectionString": "mongodb://{mongodb1.bindings.tcp.host}:{mongodb1.bindings.tcp.port}",
      "image": "mongo:7.0.5",
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 27017
        }
      }
    },
    "shipping": {
      "type": "value.v0",
      "connectionString": "{mongodb1.connectionString}/shipping"
    }
  }
}

typy prostředků MySQL

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddMySql("mysql1")
       .AddDatabase("shipping");

Příklad manifestu:

{
  "resources": {
    "mysql1": {
      "type": "container.v0",
      "connectionString": "Server={mysql1.bindings.tcp.host};Port={mysql1.bindings.tcp.port};User ID=root;Password={mysql1.inputs.password}",
      "image": "mysql:8.3.0",
      "env": {
        "MYSQL_ROOT_PASSWORD": "{mysql1.inputs.password}"
      },
      "bindings": {
        "tcp": {
          "scheme": "tcp",
          "protocol": "tcp",
          "transport": "tcp",
          "containerPort": 3306
        }
      },
      "inputs": {
        "password": {
          "type": "string",
          "secret": true,
          "default": {
            "generate": {
              "minLength": 10
            }
          }
        }
      }
    },
    "shipping": {
      "type": "value.v0",
      "connectionString": "{mysql1.connectionString};Database=shipping"
    }
  }
}

Azure– konkrétní typy prostředků

V 📦Aspirejsou k dispozici následující zdroje informací. Hostování.Azure balíčku NuGet.

Využití modelu aplikace	Typ prostředku manifestu	Odkaz na nadpis
AddAzureAppConfiguration	`azure.bicep.v0`	typy prostředků Azure App Configuration
AddAzureKeyVault	`azure.bicep.v0`	Azure Key Vault typ prostředku
`AddAzureRedis`	`azure.bicep.v0`	Azure Redis typy prostředků
AddAzureServiceBus	`azure.bicep.v0`	Azure Service Bus typ prostředku
`AddAzureSqlServer(...)`	`azure.bicep.v0`	Azure typy prostředků SQL
`AddAzureSqlServer(...).AddDatabase(...)`	`value.v0`	Azure typy prostředků SQL
`AddAzurePostgresFlexibleServer(...)`	`azure.bicep.v0`	Azure Postgres typy prostředků
`AddAzurePostgresFlexibleServer(...).AddDatabase(...)`	`value.v0`	Azure Postgres typy prostředků
AddAzureStorage	`azure.storage.v0`	Azure typy prostředků úložiště
AddBlobs	`value.v0`	Azure typy prostředků úložiště
AddQueues	`value.v0`	Azure typy prostředků úložiště
AddTables	`value.v0`	Azure typy prostředků úložiště

typ prostředku Azure Key Vault

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzureKeyVault("keyvault1");

Příklad manifestu:

{
  "resources": {
    "keyvault1": {
      "type": "azure.bicep.v0",
      "connectionString": "{keyvault1.outputs.vaultUri}",
      "path": "aspire.hosting.azure.bicep.keyvault.bicep",
      "params": {
        "principalId": "",
        "principalType": "",
        "vaultName": "keyvault1"
      }
    }
  }
}

typ prostředku Azure Service Bus

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzureServiceBus("sb1")
       .AddTopic("topic1", [])
       .AddTopic("topic2", [])
       .AddQueue("queue1")
       .AddQueue("queue2");

Příklad manifestu:

{
  "resources": {
    "sb1": {
      "type": "azure.bicep.v0",
      "connectionString": "{sb1.outputs.serviceBusEndpoint}",
      "path": "aspire.hosting.azure.bicep.servicebus.bicep",
      "params": {
        "serviceBusNamespaceName": "sb1",
        "principalId": "",
        "principalType": "",
        "queues": [
          "queue1",
          "queue2"
        ],
        "topics": [
          {
            "name": "topic1",
            "subscriptions": []
          },
          {
            "name": "topic2",
            "subscriptions": []
          }
        ]
      }
    }
  }
}

Azure typy prostředků úložiště

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

var storage = builder.AddAzureStorage("images");

storage.AddBlobs("blobs");
storage.AddQueues("queues");
storage.AddTables("tables");

Příklad manifestu:

{
  "resources": {
    "images": {
      "type": "azure.bicep.v0",
      "path": "aspire.hosting.azure.bicep.storage.bicep",
      "params": {
        "principalId": "",
        "principalType": "",
        "storageName": "images"
      }
    },
    "blobs": {
      "type": "value.v0",
      "connectionString": "{images.outputs.blobEndpoint}"
    },
    "queues": {
      "type": "value.v0",
      "connectionString": "{images.outputs.queueEndpoint}"
    },
    "tables": {
      "type": "value.v0",
      "connectionString": "{images.outputs.tableEndpoint}"
    }
  }
}

typ prostředku AzureRedis

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzureRedis("azredis1");

Příklad manifestu:

{
  "resources": {
    "azredis": {
      "type": "azure.bicep.v0",
      "connectionString": "{azredis.outputs.connectionString}",
      "path": "azredis.module.bicep",
      "params": {
        "principalId": "",
        "principalName": ""
      }
    }
  }
}

typ prostředku Azure App Configuration

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzureAppConfiguration("appconfig1");

Příklad manifestu:

{
  "resources": {
    "appconfig1": {
      "type": "azure.bicep.v0",
      "connectionString": "{appconfig1.outputs.appConfigEndpoint}",
      "path": "aspire.hosting.azure.bicep.appconfig.bicep",
      "params": {
        "configName": "appconfig1",
        "principalId": "",
        "principalType": ""
      }
    }
  }
}

Azure typy prostředků SQL

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzureSqlServer("sql")
       .AddDatabase("inventory");

Příklad manifestu:

{
  "resources": {
    "sql": {
      "type": "azure.bicep.v0",
      "connectionString": "Server=tcp:{sql.outputs.sqlServerFqdn},1433;Encrypt=True;Authentication=\u0022Active Directory Default\u0022",
      "path": "sql.module.bicep",
      "params": {
        "principalId": "",
        "principalName": ""
      }
    },
    "inventory": {
      "type": "value.v0",
      "connectionString": "{sql.connectionString};Database=inventory"
    }
  }
}

typy prostředků AzurePostgres

Příklad kódu:

var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzurePostgresFlexibleServer("postgres")
       .AddDatabase("db");

Příklad manifestu:

{
  "resources": {
    "postgres": {
      "type": "azure.bicep.v0",
      "connectionString": "{postgres.outputs.connectionString}",
      "path": "postgres.module.bicep",
      "params": {
        "principalId": "",
        "principalType": "",
        "principalName": ""
      }
    },
    "db": {
      "type": "value.v0",
      "connectionString": "{postgres.connectionString};Database=db"
    }
  }
}

Typy prostředků podporované v Azure Developer CLI

Azure Developer CLI (azd) je nástroj, který lze použít k nasazení .NET Aspire projektů do Azure Container Apps. U typu prostředku azure.bicep.v0 je možné namapovat typy kontejnerů prostředků nezávislé na cloudu na Azure–specifické prostředky. Následující tabulka uvádí typy prostředků podporované v Azure Developer CLI:

Jméno	Cloudové nezávislé rozhraní API	Azure API
Redis	AddRedis	`AddAzureRedis`
Postgres	AddPostgres	`AddAzurePostgresFlexibleServer`
SQL Server	AddSqlServer	`AddAzureSqlServer`

Pokud jsou prostředky nakonfigurované jako Azure prostředky, v manifestu se vygeneruje typ azure.bicep.v0 prostředku. Další informace najdete v tématu Nasazení projektu .NET Aspire pro Azure Container Apps pomocí Azure Developer CLI (podrobný průvodce).

Viz také

přehled .NET.NET Aspire
Přehled orchestrace
Přehled integrace .NET.NET Aspire
Zjišťování služby v .NET.NET Aspire

Sdílet prostřednictvím

.NET .NET Aspire formátu manifestu pro tvůrce nástrojů pro nasazení

Vygenerování manifestu

Základní formát manifestu

Připojovací řetězec a odkazy na vazby

Struktura zástupného řetězce

Typy prostředků

Běžná pole zdrojů

Pole `inputs`

Předdefinované prostředky

Typy prostředků nezávislé na cloudu

Typ zdroje projektu

Typ prostředku kontejneru

typy prostředků Dockerfile

typy prostředků Postgres

typy prostředků RabbitMQ

typ prostředku Redis

typy prostředků SQL Server

typy prostředků MongoDB

typy prostředků MySQL

Azure– konkrétní typy prostředků

typ prostředku Azure Key Vault

typ prostředku Azure Service Bus

Azure typy prostředků úložiště

typ prostředku AzureRedis

typ prostředku Azure App Configuration

Azure typy prostředků SQL

typy prostředků AzurePostgres

Typy prostředků podporované v Azure Developer CLI

Viz také

Další materiály

Sdílet prostřednictvím

.NET .NET Aspire formátu manifestu pro tvůrce nástrojů pro nasazení

Vygenerování manifestu

Základní formát manifestu

Připojovací řetězec a odkazy na vazby

Struktura zástupného řetězce

Typy prostředků

Běžná pole zdrojů

Pole inputs

Předdefinované prostředky

Typy prostředků nezávislé na cloudu

Typ zdroje projektu

Typ prostředku kontejneru

typy prostředků Dockerfile

typy prostředků Postgres

typy prostředků RabbitMQ

typ prostředku Redis

typy prostředků SQL Server

typy prostředků MongoDB

typy prostředků MySQL

Azure– konkrétní typy prostředků

typ prostředku Azure Key Vault

typ prostředku Azure Service Bus

Azure typy prostředků úložiště

typ prostředku AzureRedis

typ prostředku Azure App Configuration

Azure typy prostředků SQL

typy prostředků AzurePostgres

Typy prostředků podporované v Azure Developer CLI

Viz také

Další materiály

Pole `inputs`