快速入门：使用 TypeSpec 和 TypeScript 创建新的 API 项目

2025-07-29

在本快速入门中：了解如何使用 TypeSpec 设计、生成和实现 RESTful TypeScript API 应用程序。 TypeSpec 是一种开源语言，用于描述云服务 API，并为多个平台生成客户端和服务器代码。按照本快速入门作，了解如何定义 API 协定一次并生成一致的实现，从而帮助你构建更易维护且记录良好的 API 服务。

在本快速入门中，请执行以下操作：

使用 TypeSpec 定义 API
创建 API 服务器应用程序
将 Azure Cosmos DB 集成以实现持久存储
部署到 Azure 云
运行和测试 API

Important

@typespec/http-server-js 发出器当前处于预览状态。这些与预发行产品相关的信息在发布前可能进行重大修改。 Microsoft 不对此处提供的信息作任何明示或默示的担保。

Prerequisites

有效的 Azure 帐户。如果没有帐户，请免费创建帐户。
Node.js LTS 安装在您的系统上。
TypeScript 用于编写和编译 TypeScript 代码。
Docker
Visual Studio Code
TypeSpec extension
可选：使用 Azure 开发人员 CLI 进行部署

使用 TypeSpec 进行开发

TypeSpec 以与语言无关的方式定义 API，并为多个平台生成 API 服务器和客户端库。此功能用于：

定义 API 协定一次
生成一致的服务器和客户端代码
专注于实现业务逻辑而不是 API 基础结构

TypeSpec 提供 API 服务管理：

API 定义语言
API 的服务器端路由中间件
用于使用 API 的客户端库

提供客户端请求和服务器集成：

在中间件（例如用于数据库、存储和消息传送的 Azure 服务）中实现业务逻辑
为 API 托管服务器（本地或 Azure 中）
用于可重复预配和部署的部署脚本

创建新的 TypeSpec 应用程序

创建新文件夹以保存 API 服务器和 TypeSpec 文件。
```
mkdir my_typespec_quickstart
cd my_typespec_quickstart
```
全局安装 TypeSpec 编译器：
```
npm install -g @typespec/compiler
```
检查是否正确安装了 TypeSpec：
```
tsp --version
```
初始化 TypeSpec 项目：
```
tsp init
```
使用提供的答案回答以下提示：
- 在此处初始化新项目？ Y
- 选择项目模板？通用 REST API
- 输入项目名称：Widgets
- 要使用的发射器是什么？
  - OpenAPI 3.1 文档
  - JavaScript 服务器存根
TypeSpec 生成器 是利用各种 TypeSpec 编译器 API 反思 TypeSpec 编译过程并生成工件的库。
等待初始化完成，然后继续。
编译项目：
```
tsp compile .
```
TypeSpec 会在其中生成默认项目 ./tsp-output，并创建两个单独的文件夹：
- 架构是 OpenApi 3 规范。请注意，./main.tsp 中的几行代码为您生成了超过 200 行的 OpenApi 规范。
- 服务器 是生成的中间件。此中间件可以合并到 Node.js 服务器项目中。
  - ./tsp-output/js/src/generated/models/all/demo-service.ts 定义小组件 API 的接口。
  - ./tsp-output/js/src/generated/http/openapi3.ts 将 Open API 规范定义为 TypeScript 文件，并在每次编译 TypeSpec 项目时重新生成。

配置 TypeSpec 发射器

使用 TypeSpec 文件将 API 服务器生成配置为搭建整个 Express.js 服务器的基架。

打开 ./tsconfig.yaml，将现有配置替换为以下 YAML：

emit:
  - "@typespec/openapi3"
  - "@typespec/http-server-js"
options:
  "@typespec/openapi3":
    emitter-output-dir: "{output-dir}/server/schema"
    openapi-versions:
      - 3.1.0
  "@typespec/http-server-js":
    emitter-output-dir: "{output-dir}/server"
    express: true

此配置创建完整的 Express.js API 服务器：

express：生成 Express.js API 服务器，包括 Swagger UI。
emitter-output-dir：将所有内容生成到 ./server 目录中。

删除现有 ./tsp-output。别担心，在下一步中将生成服务器。
使用 TypeSpec JavaScript 发出器创建 Express.js 服务器：
```
npx hsjs-scaffold
```
切换到新 ./tsp-output/server 目录：
```
cd ./tsp-output/server
```
将 TypeScript 编译为 JavaScript。
```
tsc
```
运行项目：
```
npm start
```
请等待通知，然后 在浏览器中打开。
打开浏览器并转到 http://localhost:3000/.api-docs。
默认 TypeSpec API 和服务器都正常工作。如果要完成此 API 服务器，请在 ./tsp-output/server/src/controllers/widgets.ts 中添加业务逻辑以支持控件 API。 UI 连接到返回硬编码假数据的 API。

了解应用程序文件结构

在tsp-output/server/可以找到 Express.js 项目结构，其中包括生成的服务器、package.json 文件，以及用于 Azure 集成的中间件。

server
├── package.json
├── package-lock.json
├── src
│   ├── controllers
│   │   └── widgets.ts
│   ├── generated
│   │   ├── helpers
│   │   │   ├── datetime.ts
│   │   │   ├── header.ts
│   │   │   ├── http.ts
│   │   │   ├── multipart.ts
│   │   │   ├── router.ts
│   │   │   └── temporal
│   │   │       ├── native.ts
│   │   │       └── polyfill.ts
│   │   ├── http
│   │   │   ├── openapi3.ts
│   │   │   ├── operations
│   │   │   │   └── server-raw.ts
│   │   │   └── router.ts
│   │   └── models
│   │       └── all
│   │           ├── demo-service.ts
│   │           └── typespec.ts
│   ├── index.ts
│   └── swagger-ui.ts

父 TypeSpec 项目的文件结构中包括此 Express.js 项目 tsp-output。

├── tsp-output
├── .gitignore
├── main.tsp
├── package-lock.json
├── package.json
├── tspconfig.yaml

将数据持久性更改为 Azure Cosmos DB NoSQL

现在，基本 Express.js API 服务器正在运行，请更新 Express.js 服务器，以便与 Azure Cosmos DB 一起使用，以便存储持久性数据存储。这包括对 index.ts 在中间件中使用 Cosmos DB 集成所做的更改。所有更改都应发生在 ./tsp-output/server/src/generated 目录之外。

在 ./tsp-output/server 目录中，将 Azure Cosmos DB 添加到项目：
```
npm install @azure/cosmos
```
添加 Azure 标识库以向 Azure 进行身份验证：
```
npm install @azure/identity
```
创建一个 ./tsp-output/server/src/azure 目录来保存特定于 Azure 的源代码。

在该 cosmosClient.ts 目录中创建文件以创建 Cosmos DB 客户端对象并粘贴以下代码：

import { CosmosClient, Database, Container } from "@azure/cosmos";
import { DefaultAzureCredential } from "@azure/identity";

/**
 * Interface for CosmosDB configuration settings
 */
export interface CosmosConfig {
  endpoint: string;
  databaseId: string;
  containerId: string;
  partitionKey: string;
} 

/**
 * Singleton class for managing CosmosDB connections
 */
export class CosmosClientManager {
  private static instance: CosmosClientManager;
  private client: CosmosClient | null = null;
  private config: CosmosConfig | null = null;

  private constructor() {}

  /**
   * Get the singleton instance of CosmosClientManager
   */
  public static getInstance(): CosmosClientManager {
    if (!CosmosClientManager.instance) {
      CosmosClientManager.instance = new CosmosClientManager();
    }
    return CosmosClientManager.instance;
  }

  /**
   * Initialize the CosmosDB client with configuration if not already initialized
   * @param config CosmosDB configuration
   */
  private ensureInitialized(config: CosmosConfig): void {
    if (!this.client || !this.config) {
      this.config = config;
      this.client = new CosmosClient({
        endpoint: config.endpoint,
        aadCredentials: new DefaultAzureCredential(),
      });
    }
  }

  /**
   * Get a database instance, creating it if it doesn't exist
   * @param config CosmosDB configuration
   * @returns Database instance
   */
  private async getDatabase(config: CosmosConfig): Promise<Database> {
    this.ensureInitialized(config);
    const { database } = await this.client!.databases.createIfNotExists({ id: config.databaseId });
    return database;
  }

  /**
   * Get a container instance, creating it if it doesn't exist
   * @param config CosmosDB configuration
   * @returns Container instance
   */
  public async getContainer(config: CosmosConfig): Promise<Container> {
    const database = await this.getDatabase(config);
    const { container } = await database.containers.createIfNotExists({
      id: config.containerId,
      partitionKey: { paths: [config.partitionKey] }
    });
    return container;
  }

  /**
   * Clean up resources and close connections
   */
  public dispose(): void {
    this.client = null;
    this.config = null;
  }
}

export const buildError = (error: any, message: string) => {
  const statusCode = error?.statusCode || 500;
  return {
    code: statusCode,
    message: `${message}: ${error?.message || 'Unknown error'}`
  };
};

请注意，该文件使用终结点、数据库和容器。它不需要连接字符串或密钥，因为它使用的是 Azure 标识凭据 DefaultAzureCredential。详细了解本地环境和生产环境的这种安全身份验证方法。

创建新的 Widget 控制器，./tsp-output/server/src/controllers/WidgetsCosmos.ts，并粘贴 Azure Cosmos DB 的以下集成代码。

import { Widgets, Widget, WidgetList,   AnalyzeResult,Error } from "../generated/models/all/demo-service.js";
import { WidgetMergePatchUpdate } from "../generated/models/all/typespec/http.js";
import { CosmosClientManager, CosmosConfig, buildError } from "../azure/cosmosClient.js";
import { HttpContext } from "../generated/helpers/router.js";
import { Container } from "@azure/cosmos";

export interface WidgetDocument extends Widget {
  _ts?: number;
  _etag?: string;
}

/**
 * Implementation of the Widgets API using Azure Cosmos DB for storage
 */
export class WidgetsCosmosController implements Widgets<HttpContext>  {
  private readonly cosmosConfig: CosmosConfig;
  private readonly cosmosManager: CosmosClientManager;
  private container: Container | null = null;

  /**
   * Creates a new instance of WidgetsCosmosController
   * @param azureCosmosEndpoint Cosmos DB endpoint URL
   * @param databaseId The Cosmos DB database ID
   * @param containerId The Cosmos DB container ID
   * @param partitionKey The partition key path
   */
  constructor(azureCosmosEndpoint: string, databaseId: string, containerId: string, partitionKey: string) {
    if (!azureCosmosEndpoint) throw new Error("azureCosmosEndpoint is required");
    if (!databaseId) throw new Error("databaseId is required");
    if (!containerId) throw new Error("containerId is required");
    if (!partitionKey) throw new Error("partitionKey is required");

    this.cosmosConfig = {
      endpoint: azureCosmosEndpoint,
      databaseId: databaseId,
      containerId: containerId,
      partitionKey: partitionKey
    };

    this.cosmosManager = CosmosClientManager.getInstance();
  }

  /**
   * Get the container reference, with caching
   * @returns The Cosmos container instance
   */
  private async getContainer(): Promise<Container | null> {
    if (!this.container) {
      try {
        this.container = await this.cosmosManager.getContainer(this.cosmosConfig);
        return this.container;
      } catch (error: any) {
        console.error("Container initialization error:", error);
        throw buildError(error, `Failed to access container ${this.cosmosConfig.containerId}`);
      }
    }
    return this.container;
  }

  /**
   * Create a new widget
   * @param widget The widget to create
   * @returns The created widget with assigned ID
   */
  async create(ctx: HttpContext,
    body: Widget
  ): Promise<Widget | Error> {

    const id = body.id;

    try {
      const container = await this.getContainer();

      if(!container) {
        return buildError({statusCode:500}, "Container is not initialized");
      }

      if (!body.id) {
        return buildError({statusCode:400}, "Widget ID is required");
      }

      const response = await container.items.create<Widget>(body, { 
        disableAutomaticIdGeneration: true 
      });

      if (!response.resource) {
        return buildError({statusCode:500}, `Failed to create widget ${body.id}: No resource returned`);
      }

      return this.documentToWidget(response.resource);
    } catch (error: any) {
      if (error?.statusCode === 409) {
        return buildError({statusCode:409}, `Widget with id ${id} already exists`);
      }
      return buildError(error, `Failed to create widget ${id}`);
    }
  }

  /**
   * Delete a widget by ID
   * @param id The ID of the widget to delete
   */
  async delete(ctx: HttpContext, id: string): Promise<void | Error> {
    try {
      const container = await this.getContainer();

      if(!container) {
        return buildError({statusCode:500}, "Container is not initialized");
      }

      await container.item(id, id).delete();
    } catch (error: any) {
      if (error?.statusCode === 404) {
        return buildError({statusCode:404}, `Widget with id ${id} not found`);
      }
      return buildError(error, `Failed to delete widget ${id}`);
    }
  }

  /**
   * Get a widget by ID
   * @param id The ID of the widget to retrieve
   * @returns The widget if found
   */
  async read(ctx: HttpContext, id: string): Promise<Widget | Error> {
    try {
      const container = await this.getContainer();

      if(!container) {
        return buildError({statusCode:500}, "Container is not initialized");
      }

      const { resource } = await container.item(id, id).read<WidgetDocument>();

      if (!resource) {
        return buildError({statusCode:404}, `Widget with id ${id} not found`);
      }

      return this.documentToWidget(resource);
    } catch (error: any) {
      return buildError(error, `Failed to read widget ${id}`);
    }
  }

  /**
   * List all widgets with optional paging
   * @returns List of widgets
   */
  async list(ctx: HttpContext): Promise<WidgetList | Error> {
    try {
      const container = await this.getContainer();

      if(!container) {
        return buildError({statusCode:500}, "Container is not initialized");
      }

      const { resources } = await container.items
        .query({ query: "SELECT * FROM c" })
        .fetchAll();

      return { items: resources.map(this.documentToWidget) };
    } catch (error: any) {
      return buildError(error, "Failed to list widgets");
    }
  }

  /**
   * Update an existing widget
   * @param id The ID of the widget to update
   * @param body The partial widget data to update
   * @returns The updated widget
   */
  async update(
    ctx: HttpContext,
    id: string,
    body: WidgetMergePatchUpdate,
  ): Promise<Widget | Error> {
    try {
      const container = await this.getContainer();

      if(!container) {
        return buildError({statusCode:500}, "Container is not initialized");
      }

      // First check if the widget exists
      const { resource: item } = await container.item(id).read<WidgetDocument>();
      if (!item) {
        return buildError({statusCode:404}, `Widget with id ${id} not found`);
      }

      // Apply patch updates to the existing widget
      const updatedWidget: Widget = {
        ...item,
        ...body,
        id
      };

      // Replace the document in Cosmos DB
      const { resource } = await container.item(id).replace(updatedWidget);

      if (!resource) {
        return buildError({statusCode:500}, `Failed to update widget ${id}: No resource returned`);
      }

      return this.documentToWidget(resource);
    } catch (error: any) {
      return buildError(error, `Failed to update widget ${id}`);
    }
  }

  async analyze(ctx: HttpContext, id: string): Promise<AnalyzeResult | Error> {
    return {
      id: "mock-string",
      analysis: "mock-string",
    };
  }

  /**
   * Convert a Cosmos DB document to a Widget
   */
  private documentToWidget(doc: WidgetDocument): Widget {
    return Object.fromEntries(
      Object.entries(doc).filter(([key]) => !key.startsWith('_'))
    ) as Widget;
  }
}

更新 ./tsp-output/server/src/index.ts 以导入新控制器，检索 Azure Cosmos DB 环境设置，然后创建 WidgetsCosmosController 并传递给路由器。

// Generated by Microsoft TypeSpec

import { WidgetsCosmosController } from "./controllers/WidgetsCosmos.js";

import { createDemoServiceRouter } from "./generated/http/router.js";

import express from "express";

import morgan from "morgan";

import { addSwaggerUi } from "./swagger-ui.js";

const azureCosmosEndpoint = process.env.AZURE_COSMOS_ENDPOINT!;
const azureCosmosDatabase = "WidgetDb";
const azureCosmosContainer = "Widgets";
const azureCosmosPartitionKey = "/Id";

const router = createDemoServiceRouter(
  new WidgetsCosmosController(
    azureCosmosEndpoint, 
    azureCosmosDatabase, 
    azureCosmosContainer, 
    azureCosmosPartitionKey)
);
const PORT = process.env.PORT || 3000;

const app = express();

app.use(morgan("dev"));

const SWAGGER_UI_PATH = process.env.SWAGGER_UI_PATH || "/.api-docs";

addSwaggerUi(SWAGGER_UI_PATH, app);

app.use(router.expressMiddleware);

app.listen(PORT, () => {
  console.log(`Server is running at http://localhost:${PORT}`);
  console.log(
    `API documentation is available at http://localhost:${PORT}${SWAGGER_UI_PATH}`,
  );
});

在终端中 ./tsp-output/server，将 TypeScript 编译为 JavaScript。
```
tsc
```
该项目现在使用 Cosmos DB 集成进行生成。让我们创建部署脚本来创建 Azure 资源并部署项目。

创建部署基础结构

使用 Azure 开发人员 CLI 和 Bicep 模板创建可重复部署所需的文件。

在 TypeSpec 项目的根目录中，创建 azure.yaml 部署定义文件并粘贴到以下源中：

# yaml-language-server: $schema=https://raw.githubusercontent.com/Azure/azure-dev/main/schemas/v1.0/azure.yaml.json

name: azure-typespec-scaffold-js
metadata:
    template: azd-init@1.14.0
services:
    api:
        project: ./
        host: containerapp
        language: js
        docker:
            path: Dockerfile
pipeline:
  provider: github
hooks:
  postprovision:
    windows:
      shell: pwsh
      run: |
        # Set environment variables for the Container App
        azd env set AZURE_COSMOS_ENDPOINT "$env:AZURE_COSMOS_ENDPOINT"
      continueOnError: false
      interactive: true
    posix:
      shell: sh
      run: |
        # Set environment variables for the Container App
        azd env set AZURE_COSMOS_ENDPOINT "$AZURE_COSMOS_ENDPOINT"
      continueOnError: false
      interactive: true

请注意，此配置引用整个 TypeSpec 项目。

在 TypeSpec 项目的根目录中，创建 ./Dockerfile 用于为 Azure 容器应用生成容器的容器。

# Stage 1: Build stage
FROM node:20-alpine AS builder

WORKDIR /app

# Install TypeScript globally
RUN npm install -g typescript

# Copy package files first to leverage Docker layer caching
COPY package*.json ./

# Create the tsp-output/server directory structure
RUN mkdir -p tsp-output/server

# Copy server package.json 
COPY tsp-output/server/package.json ./tsp-output/server/

# Install build and dev dependencies
RUN npm i --force --no-package-lock
RUN cd tsp-output/server && npm install

# Copy the rest of the application code
COPY . .

# Build the TypeScript code
RUN cd tsp-output/server && tsc

#---------------------------------------------------------------

# Stage 2: Runtime stage
FROM node:20-alpine AS runtime

# Set NODE_ENV to production for better performance
ENV NODE_ENV=production

WORKDIR /app

# Copy only the server package files
COPY tsp-output/server/package.json ./

# Install only production dependencies
RUN npm install

# Copy all necessary files from the builder stage
# This includes the compiled JavaScript, any static assets, etc.
COPY --from=builder /app/tsp-output/server/dist ./dist

# Set default port and expose it
ENV PORT=3000
EXPOSE 3000

# Run the application
CMD ["node", "./dist/src/index.js"]

在 TypeSpec 项目的根目录中，创建目录 ./infra 。

创建一个 ./infra/main.bicepparam 文件并在以下项中复制，以定义部署所需的参数：

using './main.bicep'

param environmentName = readEnvironmentVariable('AZURE_ENV_NAME', 'dev')
param location = readEnvironmentVariable('AZURE_LOCATION', 'eastus2')
param deploymentUserPrincipalId = readEnvironmentVariable('AZURE_PRINCIPAL_ID', '')

此参数列表提供此部署所需的最低参数。

创建一个 ./infra/main.bicep 文件并复制以下内容，以定义用于预配和部署的 Azure 资源：

metadata description = 'Bicep template for deploying a GitHub App using Azure Container Apps and Azure Container Registry.'

targetScope = 'resourceGroup'
param serviceName string = 'api'
var databaseName = 'WidgetDb'
var containerName = 'Widgets'
var partitionKey = '/id'

@minLength(1)
@maxLength(64)
@description('Name of the environment that can be used as part of naming resource convention')
param environmentName string

@minLength(1)
@description('Primary location for all resources')
param location string

@description('Id of the principal to assign database and application roles.')
param deploymentUserPrincipalId string = ''

var resourceToken = toLower(uniqueString(resourceGroup().id, environmentName, location))

var tags = {
  'azd-env-name': environmentName
  repo: 'https://github.com/typespec'
}

module managedIdentity 'br/public:avm/res/managed-identity/user-assigned-identity:0.4.1' = {
  name: 'user-assigned-identity'
  params: {
    name: 'identity-${resourceToken}'
    location: location
    tags: tags
  }
}

module cosmosDb 'br/public:avm/res/document-db/database-account:0.8.1' = {
  name: 'cosmos-db-account'
  params: {
    name: 'cosmos-db-nosql-${resourceToken}'
    location: location
    locations: [
      {
        failoverPriority: 0
        locationName: location
        isZoneRedundant: false
      }
    ]
    tags: tags
    disableKeyBasedMetadataWriteAccess: true
    disableLocalAuth: true
    networkRestrictions: {
      publicNetworkAccess: 'Enabled'
      ipRules: []
      virtualNetworkRules: []
    }
    capabilitiesToAdd: [
      'EnableServerless'
    ]
    sqlRoleDefinitions: [
      {
        name: 'nosql-data-plane-contributor'
        dataAction: [
          'Microsoft.DocumentDB/databaseAccounts/readMetadata'
          'Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/items/*'
          'Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers/*'
        ]
      }
    ]
    sqlRoleAssignmentsPrincipalIds: union(
      [
        managedIdentity.outputs.principalId
      ],
      !empty(deploymentUserPrincipalId) ? [deploymentUserPrincipalId] : []
    )
    sqlDatabases: [
      {
        name: databaseName
        containers: [
          {
            name: containerName
            paths: [
              partitionKey
            ]
          }
        ]
      }
    ]
  }
}

module containerRegistry 'br/public:avm/res/container-registry/registry:0.5.1' = {
  name: 'container-registry'
  params: {
    name: 'containerreg${resourceToken}'
    location: location
    tags: tags
    acrAdminUserEnabled: false
    anonymousPullEnabled: true
    publicNetworkAccess: 'Enabled'
    acrSku: 'Standard'
  }
}

var containerRegistryRole = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  '8311e382-0749-4cb8-b61a-304f252e45ec'
) 

module registryUserAssignment 'br/public:avm/ptn/authorization/resource-role-assignment:0.1.1' = if (!empty(deploymentUserPrincipalId)) {
  name: 'container-registry-role-assignment-push-user'
  params: {
    principalId: deploymentUserPrincipalId
    resourceId: containerRegistry.outputs.resourceId
    roleDefinitionId: containerRegistryRole
  }
}

module logAnalyticsWorkspace 'br/public:avm/res/operational-insights/workspace:0.7.0' = {
  name: 'log-analytics-workspace'
  params: {
    name: 'log-analytics-${resourceToken}'
    location: location
    tags: tags
  }
}

module containerAppsEnvironment 'br/public:avm/res/app/managed-environment:0.8.0' = {
  name: 'container-apps-env'
  params: {
    name: 'container-env-${resourceToken}'
    location: location
    tags: tags
    logAnalyticsWorkspaceResourceId: logAnalyticsWorkspace.outputs.resourceId
    zoneRedundant: false
  }
}

module containerAppsApp 'br/public:avm/res/app/container-app:0.9.0' = {
  name: 'container-apps-app'
  params: {
    name: 'container-app-${resourceToken}'
    environmentResourceId: containerAppsEnvironment.outputs.resourceId
    location: location
    tags: union(tags, { 'azd-service-name': serviceName })
    ingressTargetPort: 3000
    ingressExternal: true
    ingressTransport: 'auto'
    stickySessionsAffinity: 'sticky'
    scaleMaxReplicas: 1
    scaleMinReplicas: 1
    corsPolicy: {
      allowCredentials: true
      allowedOrigins: [
        '*'
      ]
    }
    managedIdentities: {
      systemAssigned: false
      userAssignedResourceIds: [
        managedIdentity.outputs.resourceId
      ]
    }
    secrets: {
      secureList: [
        {
          name: 'azure-cosmos-db-nosql-endpoint'
          value: cosmosDb.outputs.endpoint
        }
        {
          name: 'user-assigned-managed-identity-client-id'
          value: managedIdentity.outputs.clientId
        }
      ]
    }
    containers: [
      {
        image: 'mcr.microsoft.com/devcontainers/typescript-node'
        name: serviceName
        resources: {
          cpu: '0.25'
          memory: '.5Gi'
        }
        env: [
          {
            name: 'AZURE_COSMOS_ENDPOINT'
            secretRef: 'azure-cosmos-db-nosql-endpoint'
          }
          {
            name: 'AZURE_CLIENT_ID'
            secretRef: 'user-assigned-managed-identity-client-id'
          }
        ]
      }
    ]
  }
}

output AZURE_COSMOS_ENDPOINT string = cosmosDb.outputs.endpoint
output AZURE_COSMOS_DATABASE string = databaseName
output AZURE_COSMOS_CONTAINER string = containerName
output AZURE_COSMOS_PARTITION_KEY string = partitionKey

output AZURE_CONTAINER_REGISTRY_ENDPOINT string = containerRegistry.outputs.loginServer
output AZURE_CONTAINER_REGISTRY_NAME string = containerRegistry.outputs.name

OUTPUT 变量允许将预配的云资源用于本地开发。

将应用程序部署到 Azure

可以使用 Azure 容器应用将此应用程序部署到 Azure：

在项目根目录的终端中，向 Azure 开发人员 CLI 进行身份验证：
```
azd auth login
```
使用 Azure 开发人员 CLI 部署到 Azure 容器应用：
```
azd up
```
使用提供的答案回答以下提示：
- 输入唯一的环境名称： tsp-server-js
- 选择要使用的 Azure 订阅：选择订阅
- 选择要使用的 Azure 位置：选择你附近的位置
- 选择要使用的资源组：选择“创建新资源组”
- 输入新资源组的名称：接受提供的默认资源组

等待部署完成。响应包括类似于以下内容的信息：

Deploying services (azd deploy)

  (✓) Done: Deploying service api
  - Endpoint: https://container-app-123.ambitiouscliff-456.centralus.azurecontainerapps.io/


SUCCESS: Your up workflow to provision and deploy to Azure completed in 6 minutes 32 seconds.

在浏览器中使用应用程序

部署后，可以：

在控制台中，选择 Endpoint URL 以在浏览器中打开它。
将路由 /.api-docs添加到终结点以使用 Swagger UI。
使用“ 立即试用” 功能在每个方法上通过 API 创建、读取、更新和删除小组件。

扩展应用程序

完成整个端到端过程后，请继续生成 API：

详细了解 TypeSpec 语言，以便在 ./main.tsp 中添加更多 API 和 API 层功能。
在中添加更多发射器并配置它们的参数。
在 TypeSpec 文件中添加更多功能时，请在服务器项目中使用源代码支持这些更改。
继续通过 Azure 标识使用无密码身份验证。

清理资源

完成本快速入门后，可以删除 Azure 资源：

azd down

或者直接从 Azure 门户删除资源组。