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

• C#
• Java
• JavaScript
• PowerShell
• Python
• TypeScript
• Övrigt (Go/Rust)

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.

Slutförande av den här snabbstarten medför en liten kostnad på några USD-cent eller mindre på ditt Azure-konto.

Konfigurera din miljö

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

Kör

• 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.

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.

• Rust-verktygskedja med rustup. rustc --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 startar en paketbaserad installation av den senaste versionen av Core Tools.

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.

1. Välj Azure-ikonen i aktivitetsfältet. Välj sedan knappen i området + Arbetsyta (lokal) och välj Skapa funktion i listrutan. När du uppmanas till det väljer du Skapa nytt projekt.

   

2. 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.

3. Ange följande information i meddelanderutorna:

   Prompt	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 om auktoriseringsnivå finns i Auktoriseringsnycklar.
   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

1. 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).

2. 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))
   }
   

3. Tryck på Ctrl + Skift + ' eller välj Ny terminal på terminalmenyn för att öppna en ny integrerad terminal i VS Code.

4. 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
   

   

Rost

1. Tryck på Ctrl + Skift + ' eller välj Ny terminal på terminalmenyn för att öppna en ny integrerad terminal i VS Code.

2. Initiera ett Rust-projekt med namnet handleri funktionsappens rot (samma mapp som host.json).

   cargo init --name handler
   

3. 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"] }
   

4. 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
   }
   

5. 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.

1. Öppna host.json.

2. I avsnittet customHandler.description anger du värdet defaultExecutablePath för till handler (i Windows anger du det till handler.exe).

3. 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.

4. 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.

1. Starta funktionsappen i den integrerade terminalen med Hjälp av Azure Functions Core Tools.

   func start
   

2. 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

3. Ett svar returneras, vilket ser ut så här i en webbläsare:

   

4. Information om begäran visas i terminalpanelen .

   

5. 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.

Logga in på Azure

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

1. Om du inte redan är inloggad väljer du Azure-ikonen i aktivitetsfältet. I området Resurser väljer du Sedan 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....

2. När du uppmanas till 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.

3. När du har loggat in kan du stänga det nya webbläsarfönstret. De prenumerationer 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

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

   macOS

   GOOS=linux GOARCH=amd64 go build handler.go
   

   Linux

   GOOS=linux GOARCH=amd64 go build handler.go
   

   Windows

   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.

Rost

1. 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"
   

2. 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 .
   

3. 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.

4. 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.

1. Välj Azure-ikonen i aktivitetsfältet. I området Resurser väljer du + sedan ikonen och väljer alternativet Skapa funktionsapp i Azure.

   

2. Ange följande information i meddelanderutorna:

   Prompt	Urval
   Välj prenumeration	Välj den prenumeration som ska användas. Du ser inte detta när du bara har en prenumeration synlig under Resurser.
   Ange ett globalt unikt namn för funktionsappen	Ange ett namn som är giltigt i en URL-sökväg. Namnet du skriver verifieras för att se till att det är unikt i Azure Functions.
   Välj en körningsstack	Välj Anpassad hanterare.
   Välj en plats för nya resurser	För bättre prestanda väljer du en region nära dig.

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

   

3. 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.
   • Ett Azure Storage-standardkonto som underhåller tillstånd och annan information om dina projekt.
   • 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 App Service-plan som definierar den underliggande värden för din funktionsapp.
   • En Application Insights-instans som är ansluten till funktionsappen, som spårar användningen av dina funktioner i appen.

   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 funktionsappnamn du anger. Som standard skapas de också i samma nya resursgrupp med funktionsappen. Om du antingen vill anpassa namnen på dessa resurser eller återanvända befintliga resurser måste du publicera projektet med avancerade skapandealternativ i stället.

Distribuera projektet till Azure

Viktigt!

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

1. I området Resurser i Azure-aktiviteten letar du upp den funktionsappresurs som du nyss skapade, högerklickar på resursen och väljer Distribuera till funktionsapp....

2. När du uppmanas att skriva över tidigare distributioner väljer du Distribuera för att distribuera funktionskoden till den nya funktionsappresursen.

3. När distributionen är klar väljer du Visa utdata för att visa skapande- och distributionsresultatet, 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

1. Tillbaka i området Resurser i sidofältet expanderar du din prenumeration, din nya funktionsapp och Functions. Högerklicka (Windows) eller Ctrl – klicka (macOS) på HttpExample funktionen och välj Kör funktion nu....

   

2. I Ange begärandetext visas brödtextvärdet för begärandemeddelandet på { "name": "Azure" }. Tryck på Retur för att skicka det här begärandemeddelandet till din funktion.

3. När funktionen körs i Azure och returnerar ett svar genereras ett meddelande i Visual Studio Code.

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.

1. 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.

2. Välj din funktionsapp och tryck på Retur. Funktionsappsidan öppnas i Azure-portalen.

3. På fliken Översikt väljer du den namngivna länken bredvid Resursgrupp.

   

4. På sidan Resursgrupp granskar du listan över inkluderade resurser och kontrollerar att det är de som du vill ta bort.

5. 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