Snabbstart: Skapa en Go- eller Kod-funktion i Azure med Visual Studio Code

Artikel
11/24/2021
10 minuter för att läsa

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 Azure Functions.

Anpassade hanterare kan användas för att skapa funktioner på alla språk eller körningar genom att köra en HTTP-serverprocess. Den här artikeln har stöd för både Go och Taget.

Den här snabbstarten medför en liten kostnad på några cent eller mindre för ditt Azure-konto.

Konfigurera din miljö

Kontrollera att du har följande krav på plats innan du börjar:

Kör
Rust

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.
Den Azure Functions Core Tools version 3.x. Använd kommandot func --version för att kontrollera att det är korrekt installerat.
Gåtill , den senaste versionen rekommenderas. Använd kommandot go version för att kontrollera din version.

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.
Den Azure Functions Core Tools version 3.x. Använd kommandot func --version för att kontrollera att det är korrekt installerat.
Toolchain med uppslag. Använd kommandot rustc --version för att kontrollera din version.

Skapa ditt lokala projekt

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

Välj Azure-ikonen i Aktivitetsfältet och gör sedan följande i Azure: I området för funktioner väljer du ikonen Skapa nytt projekt....
Välj en katalogplats för projektarbetsytan och välj Välj.

Anteckning

De här stegen har utformats för att utföras utanför en arbetsyta. Välj i det här fallet inte en projektmapp som ingår i en arbetsyta.
Ange följande information i meddelanderutorna:
- Välj ett språk för ditt funktionsprojekt: Välj Custom.
- Välj en mall för projektets första funktion: Välj HTTP trigger.
- Ange ett funktionsnamn: Skriv HttpExample.
- Auktoriseringsnivå: Anonymous Välj , som gör att alla kan anropa din funktionsslutpunkt. Mer information om auktoriseringsnivå finns i Auktoriseringsnycklar.
- Välj hur du vill öppna projektet: Välj Add to workspace.
Med den här informationen Visual Studio Code ett Azure Functions med en HTTP-utlösarfunktion. Du kan visa de lokala projektfilerna i Utforskaren. Mer information om filer som skapas finns i Genererade projektfiler.

Skapa och skapa din funktion

Filen function.json 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
Rust

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å menyn Terminal 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 handler namnet ( handler.exe på Windows) är utdata i funktionsappens rotmapp.
```
go build handler.go
```

Tryck på Ctrl + Skift + eller välj Ny terminal på menyn Terminal för att öppna en ny integrerad terminal i VS Code.
I funktionsappens rot (samma mapp som host.json) initierar du ettCertifikat-projekt med namnet 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 webserverramverket web web.
```
[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 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::UNSPECIFIED, port)).await
}

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

Konfigurera funktionsappen

Funktionsvärden måste konfigureras för att köra binärkod för din anpassade hanterare när den startas.

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

Bekräfta att customHandler avsnittet ser ut som i det här exemplet. Spara filen.

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

Funktionsappen är konfigurerad för att starta din anpassade körbara hanterare.

Köra funktionen lokalt

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

I den integrerade terminalen startar du funktionsappen med Azure Functions Core Tools.
```
func start
```
När Core Tools är igång navigerar du till följande URL för att köra en GET-begäran, som innehåller ?name=Functions frågesträngen.

http://localhost:7071/api/HttpExample?name=Functions
Ett svar returneras, som 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 publicera appen måste du logga in på Azure.

Om du inte redan är inloggad väljer du Azure-ikonen i aktivitets fältet och väljer sedan Logga in på Azure i avsnittet Azure: Functions . Om du inte redan har en, kan du skapa ett kostnads fritt Azure-konto. Studenter kan skapa ett kostnads fritt Azure-konto för studenter.

Om du redan är inloggad går du till nästa avsnitt.
När du uppmanas till webbläsaren väljer du ditt Azure-konto och loggar in med dina autentiseringsuppgifter för Azure-kontot.
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 sido fä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 din binärfil och justera konfigurationen så att den matchar målplattformen innan du publicerar den till Azure.

Kör
Rust

Kompilera hanteraren till Linux/x64 i den integrerade terminalen. En handler binärfil med namnet 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
```
Ändra defaultExecutablePath i host.json från handler.exe till handler . Detta instruerar funktionsappen att köra Linux-binärfil.

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 handler binärfil med namnet 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 du defaultExecutablePath i host.json handler.exe från till handler . Detta instruerar funktionsappen att köra Linux-binärfil.
Lägg till följande rad i .funcignore-filen:
```
target
```
Detta förhindrar publicering av innehållet i målmappen.

Publicera projektet på Azure

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

Viktigt

Om du publicerar till en befintlig funktionsapp skrivs innehållet i den appen över i Azure.

Välj Azure-ikonen i aktivitetsfältet. I området Azure: Funktioner väljer du sedan knappen Distribuera till funktionsapp....
Ange följande information i meddelanderutorna:
- Välj mapp: Välj en mapp från din arbetsyta eller bläddra till en som innehåller din funktionsapp. Du ser inte detta om du redan har en giltig funktionsapp öppen.
- Välj prenumeration: Välj den prenumeration som ska användas. Du ser inte detta om du bara har en prenumeration.
- Välj Funktionsapp i Azure: Välj + Create new Function App (advanced).
  
  Viktigt
  
  Med advanced alternativet kan du välja det specifika operativsystem som funktionsappen körs på i Azure, vilket i det här fallet är Linux.
- 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 Custom Handler .
- Välj ett operativsystem: Välj Linux .
- Välj en värdplan: Välj Consumption .
- Välj en resursgrupp: Välj + Create new resource group . Ange ett namn för resursgruppen. Det här namnet måste vara unikt i din Azure-prenumeration. Du kan använda det namn som föreslås i prompten.
- Välj ett lagringskonto: Välj + Create new storage account . Det här namnet måste vara globalt unikt i Azure. Du kan använda det namn som föreslås i prompten.
- Välj en programresurs Insights: Välj + Create Application Insights resource . Det här namnet måste vara globalt unikt i Azure. Du kan använda det namn som föreslås i prompten.
- Välj en plats för nya resurser: Välj en region nära dig för att få bättre prestanda. Tillägget visar status för enskilda resurser när de skapas i Azure i meddelandefältet.
När du är klar skapas följande Azure-resurser i din prenumeration:
- En resurs grupp, som är en logisk behållare för relaterade resurser.
- Ett standard Azure Storage-kontosom upprätthåller tillstånd och annan information om dina projekt.
- En förbruknings plan som definierar den underliggande värden för din server lös Function-app.
- En Function-app som tillhandahåller miljön för att köra funktions koden. Med en Function-app kan du gruppera funktioner som en logisk enhet för enklare hantering, distribution och delning av resurser inom samma värd plan.
- En Application Insights instans som är ansluten till Function-appen, som spårar användningen av din server lös funktion.
Ett meddelande visas när funktionsappen har skapats och distributionspaketet har tillämpats.
Välj Visa utdata i det här meddelandet för att visa skapande- och distributionsresultat, 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

Gå tillbaka till avsnittet Azure: Functions i sido fältet, expandera din prenumeration, din nya Function-app och functions. Högerklicka (Windows) eller CTRL- klicka (MacOS) på HttpExample funktionen och välj Kör funktion nu....
I Ange brödtext för begäran visas bröd texten för begär ande meddelandet { "name": "Azure" } . Skicka meddelandet till din funktion genom att trycka på RETUR.
När funktionen körs i Azure och returnerar ett svar, aktive ras ett meddelande i Visual Studio Code.

Rensa resurser

När du fortsätter till Nästa steg och lägger till en Azure Storage Queue-bindning till din funktion måste du hålla alla dina 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 Function-appen och dess relaterade resurser för att undvika ytterligare kostnader.

I Visual Studio Code, trycker du på F1 för att öppna kommando paletten. I paletten kommando söker du efter och väljer Azure Functions: Open in portal .
Välj Function-appen och tryck på RETUR. Sidan Function-appen öppnas i Azure Portal.
På fliken Översikt väljer du den namngivna länken bredvid resurs grupp.
Granska listan över resurser som ingår och verifiera att det är dem som du vill ta bort på sidan Resursgrupp.
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 längst upp på sidan för att se meddelandet.

Mer information om funktions kostnader finns i uppskatta förbruknings plan kostnader.

Nästa steg

Läs mer Azure Functions anpassade hanterare