Snabbstart: Skapa en Go- eller Rust-funktion i Azure med Hjälp av Visual Studio Code

2025-05-22

I den här artikeln använder du Visual Studio Code för att skapa en anpassad hanteringsfunktion som svarar på HTTP-begäranden. När du har testat koden lokalt distribuerar du den till den serverlösa miljön i Azure Functions.

Anpassade hanterare kan användas för att skapa funktioner på valfritt språk eller körning genom att köra en HTTP-serverprocess. Den här artikeln stöder både Go och Rust.

Dricks

När du slutför den här snabbstarten skapas en app som körs i en Elastic Premium-plan, vilket kan medföra kostnader i ditt Azure-konto även när du inte använder det. Du bör rensa resurser för att ta bort funktionsappen, App Service-planen och relaterade resurser när du har slutfört artikeln.

Konfigurera din miljö

Innan du börjar ska följande förutsättningar finnas till hands:

Kör
Rost

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
Visual Studio Code på någon av plattformarna som stöds.
Azure Functions-tillägget för Visual Studio Code.
Go, den senaste versionen rekommenderas. go version Använd kommandot för att kontrollera din version.

Installera eller uppdatera Core Tools

Azure Functions-tillägget för Visual Studio Code integreras med Azure Functions Core Tools så att du kan köra och felsöka dina funktioner lokalt i Visual Studio Code med hjälp av Azure Functions-körningen. Innan du kommer igång är det en bra idé att installera Core Tools lokalt eller uppdatera en befintlig installation för att använda den senaste versionen.

I Visual Studio Code väljer du F1 för att öppna kommandopaletten och söker sedan efter och kör kommandot Azure Functions: Install eller Update Core Tools.

Det här kommandot försöker antingen starta en paketbaserad installation av den senaste versionen av Core Tools eller uppdatera en befintlig paketbaserad installation. Om du inte har npm eller Homebrew installerat på den lokala datorn måste du i stället installera eller uppdatera Core Tools manuellt.

Skapa ditt lokala projekt

I det här avsnittet använder du Visual Studio Code för att skapa ett lokalt projekt för anpassade Azure Functions-hanterare. Senare i den här artikeln ska du publicera funktionskoden till Azure.

I Visual Studio Code trycker du på F1 för att öppna kommandopaletten och söka efter och köra kommandot Azure Functions: Create New Project....
Välj katalogplatsen för projektarbetsytan och välj Välj. Du bör antingen skapa en ny mapp eller välja en tom mapp för projektarbetsytan. Välj inte en projektmapp som redan är en del av en arbetsyta.

Ange följande information i meddelanderutorna:

Omedelbar	Urval
Välj ett språk för funktionsprojektet	Välj `Custom Handler`.
Välj en mall för projektets första funktion	Välj `HTTP trigger`.
Ange ett funktionsnamn	Skriv `HttpExample`.
Auktoriseringsnivå	Välj `Anonymous`, vilket gör att vem som helst kan anropa funktionsslutpunkten. Mer information finns i auktoriseringsnivå.
Välj hur du vill öppna projektet	Välj `Open in current window`.

Med den här informationen genererar Visual Studio Code ett Azure Functions-projekt med en HTTP-utlösare. Du kan visa de lokala projektfilerna i Utforskaren.

Skapa och skapa din funktion

Den function.json filen i mappen HttpExample deklarerar en HTTP-utlösarfunktion. Du slutför funktionen genom att lägga till en hanterare och kompilera den till en körbar fil.

Kör
Rost

Tryck på Ctrl + N (Cmd + N på macOS) för att skapa en ny fil. Spara den som handler.go i funktionsappens rot (i samma mapp som host.json).

I handler.go lägger du till följande kod och sparar filen. Det här är din anpassade Go-hanterare.

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    message := "This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.\n"
    name := r.URL.Query().Get("name")
    if name != "" {
        message = fmt.Sprintf("Hello, %s. This HTTP triggered function executed successfully.\n", name)
    }
    fmt.Fprint(w, message)
}

func main() {
    listenAddr := ":8080"
    if val, ok := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT"); ok {
        listenAddr = ":" + val
    }
    http.HandleFunc("/api/HttpExample", helloHandler)
    log.Printf("About to listen on %s. Go to https://127.0.0.1%s/", listenAddr, listenAddr)
    log.Fatal(http.ListenAndServe(listenAddr, nil))
}

Tryck på Ctrl + Skift + ' eller välj Ny terminal på terminalmenyn för att öppna en ny integrerad terminal i VS Code.
Kompilera din anpassade hanterare med hjälp av följande kommando. En körbar fil med namnet handler (handler.exe i Windows) matas ut i funktionsappens rotmapp.
```
go build handler.go
```

Tryck på Ctrl + Skift + ' eller välj Ny terminal på terminalmenyn för att öppna en ny integrerad terminal i VS Code.
Initiera ett Rust-projekt med namnet i funktionsappens rot (samma mapp som handler).
```
cargo init --name handler
```
I Cargo.toml lägger du till följande beroenden som krävs för att slutföra den här snabbstarten. I exemplet används warp-webbserverramverket .
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

I src/main.rs lägger du till följande kod och sparar filen. Det här är din anpassade Rust-hanterare.

use std::collections::HashMap;
use std::env;
use std::net::Ipv4Addr;
use warp::{http::Response, Filter};

#[tokio::main]
async fn main() {
    let example1 = warp::get()
        .and(warp::path("api"))
        .and(warp::path("HttpExample"))
        .and(warp::query::<HashMap<String, String>>())
        .map(|p: HashMap<String, String>| match p.get("name") {
            Some(name) => Response::builder().body(format!("Hello, {}. This HTTP triggered function executed successfully.", name)),
            None => Response::builder().body(String::from("This HTTP triggered function executed successfully. Pass a name in the query string for a personalized response.")),
        });

    let port_key = "FUNCTIONS_CUSTOMHANDLER_PORT";
    let port: u16 = match env::var(port_key) {
        Ok(val) => val.parse().expect("Custom Handler port is not a number!"),
        Err(_) => 3000,
    };

    warp::serve(example1).run((Ipv4Addr::LOCALHOST, port)).await
}

Kompilera en binär fil för din anpassade hanterare. En körbar fil med namnet handler (handler.exe i Windows) matas ut i funktionsappens rotmapp.
```
cargo build --release
cp target/release/handler .
```

Konfigurera funktionsappen

Funktionsvärden måste konfigureras för att köra den anpassade hanterarbinärfilen när den startas.

Öppna host.json.
I avsnittet customHandler.description anger du värdet defaultExecutablePath för till handler (i Windows anger du det till handler.exe).
I avsnittet customHandler lägger du till en egenskap med namnet enableForwardingHttpRequest och anger dess värde till true. För funktioner som endast består av en HTTP-utlösare förenklar den här inställningen programmeringen så att du kan arbeta med en typisk HTTP-begäran i stället för nyttolasten för anpassad hanteringsbegäran.

Bekräfta att avsnittet customHandler ser ut så här. Spara filen.

"customHandler": {
  "description": {
    "defaultExecutablePath": "handler",
    "workingDirectory": "",
    "arguments": []
  },
  "enableForwardingHttpRequest": true
}

Funktionsappen är konfigurerad för att starta den körbara körbara hanteraren.

Kör funktionen lokalt

Du kan köra det här projektet på din lokala utvecklingsdator innan du publicerar till Azure.

Starta funktionsappen i den integrerade terminalen med Hjälp av Azure Functions Core Tools.
```
func start
```
När Core Tools körs går du till följande URL för att köra en GET-begäran, som innehåller ?name=Functions frågesträng.

http://localhost:7071/api/HttpExample?name=Functions
Ett svar returneras, vilket ser ut så här i en webbläsare:
Information om begäran visas i terminalpanelen .
Tryck på Ctrl + C för att stoppa Core Tools.

När du har kontrollerat att funktionen körs korrekt på den lokala datorn är det dags att använda Visual Studio Code för att publicera projektet direkt till Azure.

Innan du kan skapa Azure-resurser eller publicera din app måste du logga in på Azure.

Om du inte redan är inloggad går du till aktivitetsfältet och väljer Azure-ikonen. Under Resurser väljer du Logga in på Azure.

Om du redan är inloggad och kan se dina befintliga prenumerationer går du till nästa avsnitt. Om du ännu inte har ett Azure-konto väljer du Skapa ett Azure-konto. Eleverna kan välja Skapa ett Azure for Students-konto.
När du uppmanas att göra det i webbläsaren väljer du ditt Azure-konto och loggar in med dina autentiseringsuppgifter för Azure-kontot. Om du skapar ett nytt konto kan du logga in när ditt konto har skapats.
När du har loggat in kan du stänga det nya webbläsarfönstret. Prenumerationerna som tillhör ditt Azure-konto visas i sidofältet.

Kompilera den anpassade hanteraren för Azure

I det här avsnittet publicerar du projektet till Azure i en funktionsapp som kör Linux. I de flesta fall måste du kompilera om binärfilen och justera konfigurationen så att den matchar målplattformen innan du publicerar den till Azure.

Kör
Rost

Kompilera hanteraren till Linux/x64 i den integrerade terminalen. En binär med namnet handler skapas i funktionsappens rot.
- macOS
- Linux
- Windows
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
GOOS=linux GOARCH=amd64 go build handler.go
```
```
set GOOS=linux
set GOARCH=amd64
go build handler.go
```
defaultExecutablePath Ändra i host.json från handler.exe till handler. Detta instruerar funktionsappen att köra Linux-binärfilen.

Skapa en fil på .cargo/config. Lägg till följande innehåll och spara filen.
```
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
```

Kompilera hanteraren till Linux/x64 i den integrerade terminalen. En binär fil med namnet handler skapas. Kopiera den till funktionsappens rot.

rustup target add x86_64-unknown-linux-musl
cargo build --release --target=x86_64-unknown-linux-musl
cp target/x86_64-unknown-linux-musl/release/handler .

Om du använder Windows ändrar defaultExecutablePath du i host.json från handler.exe till handler. Detta instruerar funktionsappen att köra Linux-binärfilen.
Lägg till följande rad i .funcignore-filen :
```
target
```
Detta förhindrar publicering av innehållet i målmappen.

Skapa funktionsappen i Azure

I det här avsnittet skapar du en funktionsapp och relaterade resurser i din Azure-prenumeration.

I kommandopaletten anger du Azure Functions: Skapa funktionsapp i Azure... (Avancerat).
Om du inte är inloggad uppmanas du att logga in på Azure. Du kan också skapa ett kostnadsfritt Azure-konto. När du har loggat in från webbläsaren går du tillbaka till Visual Studio Code.

Ange följande information genom att följa anvisningarna:

Omedelbar	Urval
Ange ett globalt unikt namn för den nya funktionsappen.	Ange ett globalt unikt namn som identifierar din nya funktionsapp och välj sedan Retur. Giltiga tecken i ett namn på en funktionsapp är `a-z`, `0-9` och `-`.
Välj en värdplan.	Välj Premium-hostingplanen, som tillhandahåller serverlös hosting på Linux som skalar dynamiskt efter behov.
Välj en plats för nya resurser.	Välj en plats i en region nära dig eller nära andra tjänster som dina funktioner har åtkomst till. Endast regioner som stöder din valda värdplan visas.
Välj en programkörningsmiljö.	Välj Anpassad hanterare.
Välj ett operativsystem.	Välj Linux sedan appen kompilerades för att köras på Linux.
Välj en Linux App Service-plan	För Elastic Premium-abonnemang måste du uttryckligen skapa en ny App Service-plan, ange plannamnet och välja prisnivån EP1 .
Välj typ av resursautentisering	Välj Hanterad identitet, vilket är det säkraste alternativet för att ansluta till standardvärdlagringskonto. När du använder hanterade identiteter med en Elastic Premium-plan är hemlig nyckelåtkomst till standardlagringen för värdlagring aktiverad för Azure Files-åtkomst. Mer information finns i Köra utan Azure Files.
Välj ett lagringskonto.	Välj Skapa nytt lagringskonto och ange i prompten ett globalt unikt namn för det nya lagringskontot som används av funktionsappen. Lagringskontonamn måste vara mellan 3 och 24 tecken långa och får endast innehålla siffror och gemener.
Välj en Application Insights-resurs för din app.	Välj Skapa ny Application Insights-resurs och ange i kommandotolken ett namn för den instans som används för att lagra körningsdata från dina funktioner.
Välj en användartilldelad identitet	Välj Skapa en ny användartilldelad identitet. Den här identiteten används vid åtkomst till värdstandardlagringskonto med Microsoft Entra ID-autentisering.

Tillägget visar status för enskilda resurser när de skapas i Azure i panelen Azure: Aktivitetslogg .

Logg över skapande av Azure-resurser

När skapandet är klart skapas följande Azure-resurser i din prenumeration. Resurserna namnges baserat på funktionsappens namn:
- En resursgrupp, som är en logisk container för relaterade resurser.
- En funktionsapp som tillhandahåller miljön för att köra funktionskoden. Med en funktionsapp kan du gruppera funktioner som en logisk enhet för enklare hantering, distribution och delning av resurser inom samma värdplan.
- En Azure App Service-plan som definierar den underliggande värden för din funktionsapp.
- Ett Azure Storage-standardkonto som används av Functions-värden för att underhålla tillstånd och annan information om din funktionsapp.
- En Application Insights-instans som är ansluten till funktionsappen och som spårar användningen av dina funktioner i appen.
- En användartilldelad hanterad identitet som läggs till i rollen Storage Blob Data Contributor i det nya standardlagringskontot för värd.
- En användartilldelad hanterad identitet som läggs till i rollen Storage Blob Data Contributor i det nya standardlagringskontot för värd.
Ett meddelande visas när funktionsappen har skapats och distributionspaketet har tillämpats.

Dricks

Som standard skapas de Azure-resurser som krävs av funktionsappen baserat på det namn du anger för funktionsappen. Som standard skapas resurserna med funktionsappen i samma nya resursgrupp. Om du vill anpassa namnen på de associerade resurserna eller återanvända befintliga resurser publicerar du projektet med avancerade alternativ för att skapa.

Distribuera projektet till Azure

Viktigt!

Distribution till en befintlig funktionsapp skriver alltid över innehållet i appen i Azure.

I kommandopaletten anger du och väljer sedan Azure Functions: Deploy to Function App (Azure Functions: Distribuera till funktionsapp).
Välj den funktionsapp som du nyss skapade. När du uppmanas att skriva över tidigare distributioner väljer du Distribuera för att distribuera funktionskoden till den nya funktionsappresursen.
När distributionen är klar väljer du Visa utdata för att visa resultatet av skapandet och distributionen, inklusive de Azure-resurser som du skapade. Om du missar meddelandet väljer du klockikonen i det nedre högra hörnet för att se det igen.

Kör funktionen i Azure

Tryck på F1 för att visa kommandopaletten och sök sedan efter och kör kommandot Azure Functions:Execute Function Now.... Välj din prenumeration om du uppmanas att göra det.
Välj din nya funktionsappresurs och HttpExample som funktion.
I för begäran trycker du på Retur för att skicka det här begärandemeddelandet till din funktion.
När funktionen körs i Azure visas svaret i meddelandefältet. Expandera meddelandet för att granska det fullständiga svaret.

Rensa resurser

När du fortsätter till nästa steg och lägger till en Azure Storage-köbindning till din funktion måste du behålla alla resurser på plats för att bygga vidare på det du redan har gjort.

Annars kan du använda följande steg för att ta bort funktionsappen och dess relaterade resurser för att undvika ytterligare kostnader.

I Visual Studio Code trycker du på F1 för att öppna kommandopaletten. I kommandopaletten söker du efter och väljer Azure: Open in portal.
Välj din funktionsapp och tryck på Retur. Funktionsappsidan öppnas i Azure Portal.
På fliken Översikt väljer du den namngivna länken bredvid Resursgrupp.
På sidan Resursgrupp granskar du listan över inkluderade resurser och kontrollerar att det är de som du vill ta bort.
Välj Ta bort resursgrupp och följ instruktionerna.

Borttagningen kan ta några minuter. När du är färdig visas ett meddelande i några sekunder. Du kan även välja klockikonen högst upp på sidan för att se meddelandet.

Mer information om Functions-kostnader finns i Beräkna kostnader för förbrukningsplan.

Nästa steg

Läs mer om anpassade Azure Functions-hanterare

Feedback

Var den här sidan till hjälp?