Szybki start: tworzenie aplikacji MCP przy użyciu Azure Functions

W tym przewodniku szybkiego startu utworzysz aplikację Model Context Protocol (MCP) na podstawie projektu szablonu, utworzonego przy użyciu rozszerzenia Azure Functions MCP. Aplikacje MCP to serwery MCP z narzędziami, które zwracają wyniki w rozbudowanych, interaktywnych interfejsach użytkownika zamiast tekstu. Aplikację należy wdrożyć przy użyciu interfejsu wiersza polecenia dewelopera Azure (azd). Można również użyć rozszerzenia Azure Functions MCP, aby utworzyć serwery MCP, które mają narzędzia tekstowe.

Po uruchomieniu projektu lokalnie i zweryfikowaniu kodu przy użyciu GitHub Copilot wdrożysz go w nowej aplikacji funkcji bezserwerowej w Azure Functions, która jest zgodna z bieżącymi najlepszymi rozwiązaniami dotyczącymi bezpiecznych i skalowalnych wdrożeń.

Ponieważ nowa aplikacja działa w ramach planu Flex Consumption, który jest zgodny z modelem rozliczeniowym „płać za to, co używasz”, ukończenie tego szybkiego przewodnika wiąże się z niewielkim kosztem kilku centów USD lub mniej na Twoim koncie Azure.

Ważne

Rozszerzenie MCP nie obsługuje obecnie aplikacji programu PowerShell.

Ten artykuł obsługuje wersję 4 modelu programowania Node.js dla Azure Functions.

Ten artykuł obsługuje wersję 2 modelu programowania Python dla Azure Functions.

Wymagania wstępne

• SDK platformy .NET 10

• zestaw deweloperów Java 17
  • Jeśli używasz innej obsługiwanej wersji Java zaktualizuj plik pom.xml projektu.
  • Ustaw zmienną środowiskową JAVA_HOME na lokalizację instalacji poprawnej wersji zestawu Java Development Kit (JDK).
• Apache Maven 3.8.x

• Node.js 22

• Python 3.11

• Node.js (wymagane do utworzenia interfejsu użytkownika aplikacji MCP)

• Visual Studio Code z następującymi rozszerzeniami:

  • rozszerzenie Azure Functions. To rozszerzenie wymaga Azure Functions Core Tools i próbuje zainstalować je, jeśli są niedostępne.

  • Rozszerzenie Azure Developer CLI.

• Emulator magazynu Azurite

• Azure CLI. Możesz również uruchomić polecenia Azure CLI w Azure Cloud Shell.

• Konto Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.

Inicjowanie projektu

Użyj interfejsu wiersza polecenia dewelopera Azure, aby utworzyć projekt kodu Azure Functions na podstawie szablonu.

1. W terminalu uruchom to azd init polecenie, aby utworzyć projekt lokalny na podstawie szablonu:

   azd init --template remote-mcp-functions-dotnet -e mcpweather-dotnet
   

   To polecenie ściąga pliki projektu z repozytorium template i inicjuje projekt w nowym folderze. Flaga -e ustawia nazwę bieżącego środowiska. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest on również używany w nazwach zasobów tworzonych w Azure.

2. Przejdź do katalogu projektu:

   cd remote-mcp-functions-dotnet
   

1. W terminalu uruchom to azd init polecenie, aby utworzyć projekt lokalny na podstawie szablonu:

   azd init --template remote-mcp-functions-typescript -e mcpweather-ts
   

   To polecenie ściąga pliki projektu z repozytorium template i inicjuje projekt w nowym folderze. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest ona również używana w nazwach zasobów tworzonych w Azure.

2. Przejdź do katalogu projektu:

   cd remote-mcp-functions-typescript
   

1. W terminalu uruchom to azd init polecenie, aby utworzyć projekt lokalny na podstawie szablonu:

   azd init --template remote-mcp-functions-javascript -e mcpweather-js
   

   To polecenie ściąga pliki projektu z repozytorium template i inicjuje projekt w nowym folderze. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest on również używany w nazwach zasobów tworzonych w Azure.

2. Przejdź do katalogu projektu:

   cd remote-mcp-functions-javascript
   

1. W terminalu uruchom to azd init polecenie, aby utworzyć projekt lokalny na podstawie szablonu:

   azd init --template remote-mcp-functions-python -e mcpweather-python
   

   To polecenie ściąga pliki projektu z repozytorium template i inicjuje projekt w nowym folderze. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest ona również używana w nazwach zasobów tworzonych w Azure.

2. Przejdź do katalogu projektu:

   cd remote-mcp-functions-python
   

1. W terminalu uruchom to azd init polecenie, aby utworzyć projekt lokalny na podstawie szablonu:

   azd init --template remote-mcp-functions-java -e mcpweather-java
   

   To polecenie ściąga pliki projektu z repozytorium template i inicjuje projekt w nowym folderze. W azd środowisko systemowe zapewnia unikatowy kontekst wdrażania dla twojej aplikacji i można zdefiniować więcej niż jeden z nich. Jest on również używany w nazwach zasobów tworzonych w Azure.

2. Przejdź do katalogu projektu:

   cd remote-mcp-functions-java
   

3. Otwórz projekt w programie Visual Studio Code:

   code .
   

Uruchamianie emulatora magazynu

Użyj emulatora usługi Azurite, aby symulować połączenie konta Azure Storage podczas lokalnego uruchamiania projektu kodu.

1. Jeśli jeszcze tego nie zrobiono, zainstaluj aplikację Azurite.

2. Naciśnij F1. W palecie komend wyszukaj i uruchom polecenie Azurite: Start, aby uruchomić emulator magazynu lokalnego.

Tworzenie interfejsu użytkownika aplikacji MCP

Narzędzie pogodowe MCP Apps zawiera aplikację frontendową, którą należy zbudować przed uruchomieniem projektu.

1. W terminalu przejdź do folderu aplikacji interfejsu użytkownika i skompiluj aplikację:

   cd src/McpWeatherApp/app
   npm install
   npm run build
   cd ../
   

1. W terminalu przejdź do folderu aplikacji interfejsu użytkownika i skompiluj aplikację:

   cd samples/McpWeatherApp/app
   npm install
   npm run build
   cd ..
   

1. W terminalu przejdź do folderu aplikacji interfejsu użytkownika i skompiluj aplikację:

   cd src/McpWeatherApp/app
   npm install
   npm run build
   cd ../../..
   

1. W terminalu przejdź do folderu aplikacji interfejsu użytkownika i skompiluj aplikację:

   cd src/app
   npm install
   npm run build
   cd ../..
   

1. W terminalu przejdź do folderu aplikacji interfejsu użytkownika i skompiluj aplikację:

   cd mcp-weather-app/src/app
   npm install
   npm run build
   cd ../../..
   

Uruchamianie serwera MCP lokalnie

Po wyświetleniu monitu wybierz pozycję src/McpWeatherApp. Zostanie wyświetlony ten monit, ponieważ w rozwiązaniu znajdują się dwa projekty, a drugi projekt nie jest używany przez ten artykuł.

W oknie terminalu upewnij się, że jesteś w folderze samples/McpWeatherApp projektu.

Visual Studio Code integruje się z narzędziami Azure Functions Core aby umożliwić uruchamianie tego projektu na lokalnym komputerze deweloperów. Aby uruchomić aplikację usługi Functions lokalnie, naciśnij klawisz F5 lub wybierz ikonę Uruchom i debuguj na pasku działań po lewej stronie.

Na panelu Terminal są wyświetlane dane wyjściowe z narzędzi Core Tools. Aplikacja zostanie uruchomiona na panelu Terminal i będzie widoczna nazwa funkcji uruchomionych lokalnie.

Weryfikowanie przy użyciu GitHub Copilot

Szablon projektu zawiera .vscode/mcp.json plik, który definiuje local-mcp-function serwer wskazujący na lokalny punkt końcowy MCP. Użyj tej konfiguracji, aby zweryfikować kod przy użyciu GitHub Copilot w Visual Studio Code:

1. Po uruchomieniu .vscode/mcp.json funkcji lokalnie otwórz plik i wybierz przycisk Uruchom powyżej local-mcp-function konfiguracji.

2. W oknie Copilot Chat upewnij się, że wybrano tryb Agent, wybierz ikonę Konfiguruj narzędzia i sprawdź, czy MCP Server:local-mcp-function jest włączone na czacie.

3. Uruchom tę komendę:

   What's the weather in Seattle?
   

   Po wyświetleniu monitu o uruchomienie narzędzia wybierz pozycję Zezwalaj w tym obszarze roboczym , aby nie trzeba było udzielać uprawnień. Polecenie uruchamia narzędzie GetWeather, które zwraca dane pogodowe. Ponieważ to narzędzie deklaruje metadane interfejsu użytkownika, host MCP pobiera również zasób interfejsu użytkownika i renderuje interaktywny widżet pogody w osadzonym iframe w ramach czatu.

4. Po zakończeniu testowania naciśnij Ctrl+C, aby zatrzymać hosta funkcji.

Przejrzyj kod (opcjonalnie)

Możesz przejrzeć kod definiujący narzędzia MCP Apps. Narzędzie MCP Apps wymaga dwóch składników:

• Narzędzie z metadanymi interfejsu użytkownika wskazując ui.resourceUri na zasób interfejsu użytkownika.
• Zasób obsługujący dołączony kod HTML/JavaScript na zgodnym ui:// identyfikatorze URI.

Kod funkcji narzędzia pogodowego MCP Apps jest zdefiniowany w src/functions/weatherMcpApp.js pliku . W tej funkcji właściwość metadata na app.mcpTool() dodaje metadane interfejsu użytkownika do narzędzia getWeather po jego zarejestrowaniu.

  metadata: TOOL_METADATA,
  handler: getWeather,
});

Procedura getWeather obsługi pobiera dane pogodowe dla lokalizacji i zwraca je jako dane JSON.

  const location = mcptoolargs?.location ?? "";

  try {
    const result = await weatherService.getCurrentWeatherAsync(location);
    
    if ("TemperatureC" in result) {
      context.log(`Weather fetched for ${result.Location}: ${result.TemperatureC}°C`);
    } else {
      context.warn(`Weather error for ${result.Location}: ${result.Error}`);
    }

    return result;
  } catch (error) {
    context.error(`Failed to get weather for ${location}: ${error}`);
    return {
      Location: location || "Unknown",
      Error: `Unable to fetch weather: ${error instanceof Error ? error.message : String(error)}`,
      Source: "api.open-meteo.com"
    };
  }
}

// Register the GetWeatherWidget resource
app.mcpResource("getWeatherWidget", {
  uri: WEATHER_WIDGET_URI,
  resourceName: WEATHER_WIDGET_NAME,
  description: WEATHER_WIDGET_DESCRIPTION,

Funkcja app.mcpResource() rejestruje procedurę getWeatherWidget obsługi, która służy do widżetu HTML.

  handler: getWeatherWidget,
});

// Register the GetWeather tool
// Note: metadata property is not yet supported in the JavaScript SDK for mcpTool
// The TOOL_METADATA is defined for future use when the SDK is updated
app.mcpTool("getWeather", {
  toolName: "GetWeather",
  description: "Returns current weather for a location via Open-Meteo.",
  toolProperties: {

Procedura getWeatherWidget obsługująca odczytuje i zwraca opakowany plik HTML.

  context.log("Getting weather widget");
  
  try {
    // __dirname is src/functions, go up 1 level to src/, then into app/dist
    const filePath = path.join(__dirname, "..", "app", "dist", "index.html");
    return fs.readFileSync(filePath, "utf-8");
  } catch (error) {
    context.log(`Error reading weather widget file: ${error}`);
    // Return a fallback HTML if file not found
    return `<!DOCTYPE html>
<html>
<head><title>Weather Widget</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Widget content not found. Please ensure the app/dist/index.html file exists.</p>
</body>
</html>`;
  }
}

// GetWeather function - returns current weather for a location
async function getWeather(_toolArguments, context) {
  context.log("Getting weather");

Stała TOOL_METADATA deklaruje ui.resourceUri, który mówi hostowi MCP, aby pobrać interakcyjny interfejs użytkownika z ui://weather/index.html po uruchomieniu narzędzia.

const TOOL_METADATA = JSON.stringify({
  ui: {
    resourceUri: "ui://weather/index.html"
  }
});

Kompletny szablon projektu można wyświetlić w repozytorium Azure Functions JavaScript MCP Server GitHub.

Kod funkcji narzędzia pogodowego MCP Apps jest zdefiniowany w folderze src/McpWeatherApp . W tej funkcji atrybut [McpMetadata] dodaje metadane interfejsu użytkownika (UI) do narzędzia GetWeather.

[Function(nameof(GetWeather))]
public async Task<object> GetWeather(
    [McpToolTrigger(nameof(GetWeather), "Returns current weather for a location via Open-Meteo.")]
    [McpMetadata(ToolMetadata)]
        ToolInvocationContext context,
    [McpToolProperty("location", "City name to check weather for (e.g., Seattle, New York, Miami)")]
        string location)
{
    try
    {
        var result = await _weatherService.GetCurrentWeatherAsync(location);
        
        if (result is WeatherResult weather)
        {
            _logger.LogInformation("Weather fetched for {Location}: {TempC}°C", weather.Location, weather.TemperatureC);
        }
        else if (result is WeatherError error)
        {
            _logger.LogWarning("Weather error for {Location}: {Error}", error.Location, error.Error);
        }

        return result;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to get weather for {Location}", location);
        return new WeatherError(location ?? "Unknown", $"Unable to fetch weather: {ex.Message}", "api.open-meteo.com");
    }
}

Atrybut [McpResourceTrigger] jest stosowany do GetWeatherWidget funkcji, która obsługuje widżet HTML.

[Function(nameof(GetWeatherWidget))]
public string GetWeatherWidget(
    [McpResourceTrigger(
        "ui://weather/index.html",
        "Weather Widget",
        MimeType = "text/html;profile=mcp-app",
        Description = "Interactive weather display for MCP Apps")]
    [McpMetadata(ResourceMetadata)]
        ResourceInvocationContext context)
{
    var file = Path.Combine(AppContext.BaseDirectory, "app", "dist", "index.html");
    return File.ReadAllText(file);
}

Stała ToolMetadata deklaruje ui.resourceUri, który mówi hostowi MCP, aby pobrać interakcyjny interfejs użytkownika z ui://weather/index.html po uruchomieniu narzędzia.

private const string ToolMetadata = """
    {
        "ui": {
            "resourceUri": "ui://weather/index.html"
        }
    }
    """;

Funkcja GetWeatherWidget serwuje plik HTML w pakiecie pod tym identyfikatorem URI za pomocą [McpResourceTrigger].

Kompletny szablon projektu można wyświetlić w repozytorium Azure Functions .NET MCP Server GitHub.

Kod funkcji narzędzia pogodowego MCP Apps jest zdefiniowany w src/McpWeatherApp/function_app.py pliku . W tej funkcji parametr metadata na @app.mcp_tool() dodaje metadane interfejsu użytkownika do narzędzia get_weather.

# Get Weather Tool - returns current weather for a location
@app.mcp_tool(metadata=TOOL_METADATA)
@app.mcp_tool_property(arg_name="location", description="City name to check weather for (e.g., Seattle, New York, Miami)")
def get_weather(location: str) -> Dict[str, Any]:
    """Returns current weather for a location via Open-Meteo."""
    logging.info(f"Getting weather for location: {location}")
    
    try:
        result = weather_service.get_current_weather(location)
        
        if "TemperatureC" in result:
            logging.info(f"Weather fetched for {result['Location']}: {result['TemperatureC']}°C")
        else:
            logging.warning(f"Weather error for {result['Location']}: {result.get('Error', 'Unknown error')}")
        
        return json.dumps(result)
    except Exception as e:
        logging.error(f"Failed to get weather for {location}: {e}")
        return json.dumps({
            "Location": location or "Unknown",
            "Error": f"Unable to fetch weather: {str(e)}",
            "Source": "api.open-meteo.com"
        })

Dekorator @app.mcp_resource_trigger() jest stosowany do get_weather_widget funkcji, obsługującej widżet HTML.

@app.mcp_resource_trigger(
    arg_name="context",
    uri=WEATHER_WIDGET_URI,
    resource_name=WEATHER_WIDGET_NAME,
    description=WEATHER_WIDGET_DESCRIPTION,
    mime_type=WEATHER_WIDGET_MIME_TYPE,
    metadata=RESOURCE_METADATA
)
def get_weather_widget(context) -> str:
    """Get the weather widget HTML content."""
    logging.info("Getting weather widget")
    
    try:
        # Get the path to the widget HTML file
        # Current file is src/function_app.py, look for src/app/index.html
        current_dir = Path(__file__).parent
        file_path = current_dir / "app" / "dist" / "index.html"
        
        if file_path.exists():
            return file_path.read_text(encoding="utf-8")
        else:
            logging.warning(f"Weather widget file not found at: {file_path}")
            # Return a fallback HTML if file not found
            return """<!DOCTYPE html>
<html>
<head><title>Weather Widget</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Widget content not found. Please ensure the app/index.html file exists.</p>
</body>
</html>"""
    except Exception as e:
        logging.error(f"Error reading weather widget file: {e}")
        return """<!DOCTYPE html>
<html>
<head><title>Weather Widget Error</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Error loading widget content.</p>
</body>
</html>"""

Stała TOOL_METADATA deklaruje ui.resourceUri, który mówi hostowi MCP, aby pobrać interakcyjny interfejs użytkownika z ui://weather/index.html po uruchomieniu narzędzia.

TOOL_METADATA = json.dumps({"ui": {"resourceUri": "ui://weather/index.html"}})

Funkcja get_weather_widget serwuje plik HTML w pakiecie pod tym identyfikatorem URI za pomocą @app.mcp_resource_trigger().

Kompletny szablon projektu można wyświetlić w repozytorium Azure Functions Python MCP Server GitHub.

Kod funkcji narzędzia pogodowego MCP Apps jest zdefiniowany w mcp-weather-app/src/functions/weatherMcpApp.ts pliku . W tej funkcji właściwość metadata na app.mcpTool() dodaje metadane interfejsu użytkownika do narzędzia getWeather po jego zarejestrowaniu.

// Register the GetWeather tool
app.mcpTool("getWeather", {
  toolName: "GetWeather",
  description: "Returns current weather for a location via Open-Meteo.",
  toolProperties: {
    location: arg.string().describe("City name to check weather for (e.g., Seattle, New York, Miami)")
  },
  metadata: TOOL_METADATA,
  handler: getWeather,
});

Procedura getWeather obsługi pobiera dane pogodowe dla lokalizacji i zwraca je jako dane JSON.

// GetWeather function - returns current weather for a location
export async function getWeather(
  _toolArguments: unknown,
  context: InvocationContext
): Promise<object> {
  context.log("Getting weather");

  const mcptoolargs = context.triggerMetadata.mcptoolargs as {
    location?: string;
  };
  const location = mcptoolargs?.location ?? "";

  try {
    const result = await weatherService.getCurrentWeatherAsync(location);

    if ("TemperatureC" in result) {
      const weather = result as WeatherResult;
      context.log(`Weather fetched for ${weather.Location}: ${weather.TemperatureC}°C`);
    } else {
      const error = result as WeatherError;
      context.warn(`Weather error for ${error.Location}: ${error.Error}`);
    }

    return result;
  } catch (error) {
    context.error(`Failed to get weather for ${location}: ${error}`);
    return {
      Location: location || "Unknown",
      Error: `Unable to fetch weather: ${error instanceof Error ? error.message : String(error)}`,
      Source: "api.open-meteo.com"
    } as WeatherError;
  }
}

Funkcja app.mcpResource() rejestruje procedurę getWeatherWidget obsługi, która służy do widżetu HTML.

// Register the GetWeatherWidget resource
app.mcpResource("getWeatherWidget", {
  uri: WEATHER_WIDGET_URI,
  resourceName: WEATHER_WIDGET_NAME,
  description: WEATHER_WIDGET_DESCRIPTION,
  mimeType: WEATHER_WIDGET_MIME_TYPE,
  metadata: RESOURCE_METADATA,
  handler: getWeatherWidget,
});

Procedura getWeatherWidget obsługująca odczytuje i zwraca opakowany plik HTML.

// GetWeatherWidget function - returns the HTML content for the weather widget
export async function getWeatherWidget(
  resourceContext: unknown,
  context: InvocationContext
): Promise<string> {
  context.log("Getting weather widget");

  try {
    // __dirname is dist/src/functions — go up 3 levels to project root, then to src/app/dist
    const filePath = path.join(__dirname, "..", "..", "..", "src", "app", "dist", "index.html");
    return fs.readFileSync(filePath, "utf-8");
  } catch (error) {
    context.log(`Error reading weather widget file: ${error}`);
    return `<!DOCTYPE html>
<html>
<head><title>Weather Widget</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Widget content not found. Run <code>npm run build:app</code> first.</p>
</body>
</html>`;
  }
}

Stała TOOL_METADATA deklaruje ui.resourceUri, który mówi hostowi MCP, aby pobrać interakcyjny interfejs użytkownika z ui://weather/index.html po uruchomieniu narzędzia.

// Metadata for the tool (as valid JSON string)
const TOOL_METADATA = JSON.stringify({
  ui: {
    resourceUri: "ui://weather/index.html"
  }
});

Kompletny szablon projektu można wyświetlić w repozytorium Azure Functions TypeScript MCP Server GitHub.

Kod funkcji narzędzia pogodowego MCP Apps jest zdefiniowany w folderze samples/McpWeatherApp . W tej funkcji adnotacja @McpMetadata dodaje metadane interfejsu użytkownika do narzędzia GetWeather.

    try (InputStream is = getClass().getClassLoader().getResourceAsStream("app/dist/index.html")) {
        if (is != null) {
            return new String(is.readAllBytes(), StandardCharsets.UTF_8);
        }
    } catch (IOException e) {
        executionContext.getLogger().log(Level.WARNING, "Failed to read UI from classpath", e);
    }

    return "<html><body><p>Weather widget UI not found. Run <code>npm run build</code> in the <code>app/</code> directory.</p></body></html>";
}

/**
 * MCP Tool: fetches current weather for a given location.
 * <p>
 * Returns structured weather data (JSON) that the MCP host can pass to the
 * UI resource declared in the tool metadata.
 */
@FunctionName("GetWeather")
public String getWeather(
        @McpToolTrigger(
                name = "GetWeather",
                description = "Returns current weather for a location via Open-Meteo.")
        @McpMetadata(
                name = "GetWeather",
                json = TOOL_METADATA)
        String context,
        @McpToolProperty(
                name = "location",
                propertyType = "string",
                description = "City name to check weather for (e.g., Seattle, New York, Miami)")
        String location,
        final ExecutionContext executionContext) {

    executionContext.getLogger().info("GetWeather: looking up weather for '" + location + "'");

Adnotacja @McpResourceTrigger jest stosowana do GetWeatherWidget funkcji, która służy do widżetu HTML.

@FunctionName("GetWeatherWidget")
public String getWeatherWidget(
        @McpResourceTrigger(
                name = "context",
                uri = "ui://weather/index.html",
                resourceName = "Weather Widget",
                title = "Weather Widget",
                description = "Interactive weather display for MCP Apps",
                mimeType = "text/html;profile=mcp-app")
        @McpMetadata(
                name = "context",
                json = RESOURCE_METADATA)
        String context,
        final ExecutionContext executionContext) {

Stała TOOL_METADATA deklaruje ui.resourceUri, który mówi hostowi MCP, aby pobrać interakcyjny interfejs użytkownika z ui://weather/index.html po uruchomieniu narzędzia.

private static final String TOOL_METADATA = """
        {
            "ui": {
                "resourceUri": "ui://weather/index.html"
            }
        }
        """;

Funkcja GetWeatherWidget serwuje plik HTML w pakiecie pod tym identyfikatorem URI za pomocą @McpResourceTrigger.

Kompletny szablon projektu można wyświetlić w repozytorium Azure Functions Java MCP Server GitHub.

Po lokalnym zweryfikowaniu narzędzi MCP Apps możesz opublikować projekt do Azure.

Wdrażanie w Azure

Ten projekt jest skonfigurowany do użycia azd do wdrożenia tego projektu w nowej aplikacji funkcjonalnej w planie Flex Consumption w Azure. Projekt zawiera zestaw plików Bicep, które azd używa do utworzenia bezpiecznego wdrożenia w planie Flex Consumption, który jest zgodny z najlepszymi praktykami.

1. W Visual Studio Code naciśnij F1 aby otworzyć paletę poleceń. Wyszukaj i uruchom polecenie Azure Developer CLI (azd): Package, Provision and Deploy (up). Następnie zaloguj się przy użyciu konta Azure.

2. Po wyświetleniu monitu wybierz następujące wymagane parametry wdrożenia:

   Parameter	Opis
   subskrypcja Azure	Subskrypcja, w której tworzone są zasoby.
   Azure lokalizacja	Azure region, w którym należy utworzyć grupę zasobów zawierającą nowe zasoby Azure. Wyświetlane są tylko regiony, które obecnie obsługują plan Flex Consumption.
   vnetEnabled	False aby pominąć tworzenie zasobów sieci wirtualnej, co upraszcza wdrażanie.

   Po pomyślnym zakończeniu działania polecenia zobaczysz linki do utworzonych zasobów.

Ten projekt jest skonfigurowany do użycia azd do wdrożenia tego projektu w nowej aplikacji funkcjonalnej w planie Flex Consumption w Azure. Projekt zawiera zestaw plików Bicep, które azd używa do utworzenia bezpiecznego wdrożenia w planie Flex Consumption, który jest zgodny z najlepszymi praktykami.

1. W terminalu uruchom następujące azd env set polecenie:

   azd env set DEPLOY_SERVICE weather
   

   To polecenie ustawia zmienną DEPLOY_SERVICE, aby skonfigurować zasoby powiązane z aplikacją weather

2. Uruchom polecenie azd provision i podaj wymagane parametry, aby przydzielać zasoby.

   azd provision
   

   Parameter	Opis
   subskrypcja Azure	Subskrypcja, w której tworzone są zasoby.
   Azure lokalizacja	Azure region, w którym należy utworzyć grupę zasobów zawierającą nowe zasoby Azure. Wyświetlane są tylko regiony, które obecnie obsługują plan Flex Consumption.
   vnetEnabled	False aby pominąć tworzenie zasobów sieci wirtualnej, co upraszcza wdrażanie.

   Po wyświetleniu monitu wybierz subskrypcję, region Azure dla zasobów i wybierz false, aby pominąć tworzenie zasobów sieci wirtualnej w celu uproszczenia wdrażania.

3. Uruchom polecenie azd deploy, aby wdrożyć aplikację weather w Azure:

   azd deploy --service weather
   

Nawiązywanie połączenia z zdalnym serwerem MCP

Serwer MCP jest teraz uruchomiony w Azure. Szablon projektu zawiera remote-mcp-function wpis .vscode/mcp.json, który jest już skonfigurowany do łączenia się z zdalnym serwerem. Ponieważ wbudowana autoryzacja MCP jest domyślnie włączona, Visual Studio Code automatycznie obsługuje przepływ logowania OAuth po nawiązaniu połączenia.

1. Pobierz nazwę aplikacji funkcji z wdrożenia, uruchamiając to polecenie w terminalu:

   azd env get-value AZURE_FUNCTION_NAME
   

2. W .vscode/mcp.json wybierz Uruchom powyżej remote-mcp-function konfiguracji.

3. Po wyświetleniu monitu wprowadź nazwę aplikacji funkcji z poprzedniego kroku.

4. Visual Studio Code monituje o zalogowanie się przy użyciu Microsoft Entra. Postępuj zgodnie z monitami uwierzytelniania, aby autoryzować dostęp do zdalnego serwera MCP.

Zweryfikuj wdrożenie

Teraz możesz używać GitHub Copilot zdalnych narzędzi MCP tak jak lokalnie, ale teraz kod działa bezpiecznie w chmurze Azure. Powtórz te same polecenia, które były używane wcześniej, aby upewnić się, że wszystko działa poprawnie.

Uprzątnij zasoby

Po zakończeniu pracy z serwerem MCP i powiązanymi zasobami użyj tego polecenia, aby usunąć aplikację funkcji i powiązane z nią zasoby z Azure, aby uniknąć ponoszenia dalszych kosztów:

azd down 

Dalsze kroki

Konfigurowanie wbudowanej autoryzacji serwera MCP