Quickstart: Een Go- of Rust-functie maken in Azure met behulp van Visual Studio Code

Artikel
11/24/2021
11 minuten om te lezen

In dit artikel gebruikt u Visual Studio Code om een aangepaste handler-functie te maken die reageert op HTTP-aanvragen. Nadat u de code lokaal hebt getest, implementeert u deze in de serverloze omgeving van Azure Functions.

Aangepaste handlers kunnen worden gebruikt om functies in elke taal of runtime te maken door een HTTP-serverproces uit te voeren. Dit artikel biedt ondersteuning voor zowel Go als Rust.

Voor het voltooien van deze quickstart worden kosten van een paar dollarcent of minder in rekening gebracht bij uw Azure-account.

Uw omgeving configureren

Voordat u aan de slag kunt gaan, moet u beschikken over de volgende vereisten:

Go
Rust

Een Azure-account met een actief abonnement. Gratis een account maken
Visual Studio Code op een van de ondersteunde platforms.
De Azure Functions-extensie voor Visual Studio Code.
De Azure Functions Core Tools, versie 3.x. Gebruik de opdracht func --version om te controleren of deze versie correct is geïnstalleerd.
Go (nieuwste versie wordt aanbevolen). Gebruik de opdracht go version om uw versie te controleren.

Een Azure-account met een actief abonnement. Gratis een account maken
Visual Studio Code op een van de ondersteunde platforms.
De Azure Functions-extensie voor Visual Studio Code.
De Azure Functions Core Tools, versie 3.x. Gebruik de opdracht func --version om te controleren of deze versie correct is geïnstalleerd.
Rust-hulpprogrammaketen met rustup. Gebruik de opdracht rustc --version om uw versie te controleren.

Uw lokale project maken

In deze sectie gebruikt u Visual Studio Code om een lokaal Azure Functions-project voor aangepaste handlers te maken. Verderop in dit artikel publiceert u de functiecode in Azure.

Kies het Azure-pictogram in de activiteitenbalk en selecteer vervolgens in het gedeelte Azure: Functions het pictogram Nieuw project maken... .
Kies een maplocatie voor de werkruimte van uw project en kies Selecteren.

Notitie

Deze stappen waren bedoeld om buiten een werkruimte te worden voltooid. Selecteer in dit geval geen projectmap die deel uitmaakt van een werkruimte.
Geef de volgende informatie op bij de prompts:
- Selecteer een taal voor uw functieproject: Kies Custom.
- Selecteer een sjabloon voor de eerste functie van uw project: Kies HTTP trigger.
- Geef een functienaam op: Typ HttpExample.
- Autorisatieniveau: Kies Anonymous, waarmee iedereen uw functie-eindpunt kan aanroepen. Zie Autorisatiesleutels voor meer informatie over autorisatieniveau.
- Selecteer hoe u uw project wilt openen: Kies Add to workspace.
Met behulp van deze informatie wordt met Visual Studio Code een Azure Functions-project gegenereerd met een HTTP-triggerfunctie. U kunt de lokale projectbestanden weergeven in de Explorer. Zie Gegenereerde projectbestanden voor meer informatie over bestanden die worden gemaakt.

Uw functie maken en compileren

Het bestand function.json in de map HttpExample declareert een HTTP-triggerfunctie. U voltooit de functie door een handler toe te voegen en deze te compileren in een uitvoerbaar bestand.

Go
Rust

Druk op Ctrl+N (Cmd+N in macOS) om een nieuw bestand te maken. Sla het bestand op als handler.go in de hoofdmap van de functie-app (in dezelfde map als host.json).

Voeg de volgende code toe aan handler.go en sla het bestand op. Dit is uw aangepaste handler in Go.

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

Druk op Ctrl+Shift+` of selecteer Nieuwe terminal in het menu Terminal om een nieuwe geïntegreerde terminal te openen in Visual Studio Code.
Compileer uw aangepaste handler met de volgende opdracht. Een uitvoerbaar bestand met de naam handler (handler.exe in Windows) wordt uitgevoerd in de hoofdmap van de functie-app.
```
go build handler.go
```

Druk op Ctrl+Shift+` of selecteer Nieuwe terminal in het menu Terminal om een nieuwe geïntegreerde terminal te openen in Visual Studio Code.
Initialiseer een Rust-project met de naam handler in de hoofdmap van de functie-app (dezelfde map als host.json).
```
cargo init --name handler
```
Voeg in Cargo.toml de volgende afhankelijkheden toe die nodig zijn om deze quickstart te voltooien. In het voorbeeld wordt het webserverframework warp gebruikt.
```
[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["rt", "macros", "rt-multi-thread"] }
```

Voeg de volgende code toe aan src/main.rs en sla het bestand op. Dit is uw aangepaste handler in Rust.

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
}

Compileer een binair bestand voor uw aangepaste handler. Een uitvoerbaar bestand met de naam handler (handler.exe in Windows) wordt uitgevoerd in de hoofdmap van de functie-app.
```
cargo build --release
cp target/release/handler .
```

Uw functie-app configureren

De functiehost moet worden geconfigureerd om het binaire bestand van uw aangepaste handler uit te voeren wanneer deze wordt gestart.

Open host.json.
Stel in de sectie customHandler.description de waarde van defaultExecutablePath in op handler (in Windows moet u deze waarde instellen op handler.exe).
Voeg in de sectie customHandler een eigenschap toe met de naam enableForwardingHttpRequest en stel de waarde ervan in op true. Deze maakt het programmeren voor functies die uitsluitend bestaan uit een HTTP-trigger eenvoudiger, omdat u een typische HTTP-aanvraag kunt gebruiken in plaats van de aangepaste handler request payload.

Controleer of de sectie customHandler eruitziet als in dit voorbeeld. Sla het bestand op.

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

De functie-app is geconfigureerd om het uitvoerbare bestand van de aangepaste handler te starten.

De functie lokaal uitvoeren

U kunt dit project uitvoeren op uw lokale ontwikkelcomputer voordat u naar Azure publiceert.

Start de functie-app in de geïntegreerde terminal met behulp van Azure Functions Core Tools.
```
func start
```
Als Core Tools wordt uitgevoerd, navigeert u naar de volgende URL om een GET-aanvraag uit te voeren die de querytekenreeks ?name=Functions bevat.

http://localhost:7071/api/HttpExample?name=Functions
Er wordt een antwoord geretourneerd die er in een browser als volgt uitziet:
Informatie over de aanvraag wordt weergegeven in het deelvenster Terminal.
Druk op Ctrl+C om Core Tools te stoppen.

Nadat u hebt gecontroleerd of de functie correct wordt uitgevoerd op uw lokale computer, is het tijd om het project te publiceren in Azure met behulp van Visual Studio Code.

Voordat u de app kunt publiceren, moet u zich aanmelden bij Azure.

Als u niet al bent aangemeld, kiest u het Azure-pictogram in de activiteitenbalk en selecteert u vervolgens in het gedeelte Azure: Functions Aanmelden bij Azure... . Hier kunt u een gratis Azure-account maken als u dat nog niet hebt. Studenten kunnen een gratis Azure-account voor studenten maken .

Als u al bent aangemeld, gaat u naar het volgende gedeelte.
Wanneer u hierom wordt gevraagd in de browser, kiest u uw Azure-account en meld u zich aan met uw Azure-accountreferenties.
Nadat u bent aangemeld, kunt u het nieuwe browservenster sluiten. De abonnementen die bij uw Azure-account horen, worden weergegeven in de zijbalk.

De aangepaste handler voor Azure compileren

In deze sectie publiceert u uw project naar Azure in een functie-app met Linux. In de meeste gevallen moet u uw binaire bestand opnieuw compileren en de configuratie aanpassen aan het doelplatform voordat u het naar Azure publiceert.

Go
Rust

Compileer de handler in Linux/x64 in de geïntegreerde terminal. Er wordt een binair bestand met de naam handler gemaakt in de hoofdmap van de functie-app.
- 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
```
Wijzig de defaultExecutablePath in host.json van handler.exe in handler. Dit geeft de functie-app opdracht om het binaire Linux-bestand uit te voeren.

Maak een bestand in .cargo/config. Voeg de volgende inhoud toe aan het bestand en sla het op.
```
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
```
Compileer de handler in Linux/x64 in de geïntegreerde terminal. Er wordt een binair bestand met de naam handler gemaakt. Ga naar de hoofdmap van de functie-app.
```
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 .
```
Als u Windows gebruikt, wijzigt u de defaultExecutablePath in host.json van handler.exe in handler. Dit geeft de functie-app opdracht om het binaire Linux-bestand uit te voeren.
Voeg de volgende regel toe aan het bestand .funcignore:
```
target
```
Hiermee wordt voorkomen dat de inhoud van de doelmap wordt gepubliceerd.

Het project naar Azure publiceren

In deze sectie maakt u een functie-app en de bijbehorende resources in uw Azure-abonnement en implementeert u vervolgens uw code.

Belangrijk

Als u in een bestaande functie-app publiceert, wordt de inhoud van die app in Azure overschreven.

Kies het Azure-pictogram in de activiteitenbalk en selecteer vervolgens in het gedeelte Azure: In het gebied Functies kiest u de knop Implementeren in functie-app ... .
Geef de volgende informatie op bij de prompts:
- Selecteer map: Kies een map in uw werkruimte of blader naar een map die de functie-app bevat. Dit wordt niet weergegeven als u al een geldige functie-app hebt geopend.
- Selecteer abonnement: Kies het abonnement dat u wilt gebruiken. Dit ziet u niet als u maar één abonnement hebt.
- Selecteer functie-app in Azure: Kies + Create new Function App (advanced).
  
  Belangrijk
  
  Met de optie advanced kunt u het specifieke besturingssysteem kiezen waarop de functie-app wordt uitgevoerd in Azure. In dit geval is dat Linux.
- Voer een globaal unieke naam in voor de functie-app: Typ een naam die geldig is in een URL-pad. De naam die u typt, wordt gevalideerd om er zeker van te zijn dat deze uniek is in Azure Functions.
- Een runtimestack selecteren: Kies Custom Handler.
- Een besturingssysteem selecteren: Kies Linux.
- Een hostingplan selecteren: Kies Consumption.
- Een resourcegroep selecteren: Kies + Create new resource group. Voer een naam in voor de resourcegroep. Deze naam moet uniek zijn binnen uw Azure-abonnement. U kunt de naam gebruiken die wordt voorgesteld in de prompt.
- Een opslagaccount selecteren: Kies + Create new storage account. Deze naam moet wereldwijd uniek zijn in Azure. U kunt de naam gebruiken die wordt voorgesteld in de prompt.
- Een Application Insights-resource selecteren: Kies + Create Application Insights resource. Deze naam moet wereldwijd uniek zijn in Azure. U kunt de naam gebruiken die wordt voorgesteld in de prompt.
- Selecteer een locatie voor nieuwe resources: kies voor betere prestaties een regio bij u in de buurt. De extensie toont de status van afzonderlijke resources terwijl deze in het systeemgebied in Azure worden gemaakt.
Wanneer dit is voltooid, worden de volgende Azure-resources gemaakt in uw abonnement:
- Een resource groep, een logische container voor gerelateerde resources.
- Een standaard Azure Storage account, waarmee de status en andere informatie over uw projecten worden bijgehouden.
- Een verbruiksplan dat de onderliggende host definieert voor uw serverloze functie-app.
- Een functie-app, die de omgeving biedt voor het uitvoeren van uw functiecode. Met een functie-app kunt u functies groeperen in een logische eenheid, zodat u resources eenvoudiger kunt beheren, implementeren en delen binnen hetzelfde hostingabonnement.
- Een Application Insights-exemplaar dat is verbonden met de functie-app, die het gebruik van uw serverloze functie bijhoudt.
Nadat de functie-app is gemaakt en het implementatiepakket is toegepast, wordt er een melding weergegeven.
Selecteer in deze melding de optie Uitvoer weergeven om de resultaten van het maken en implementeren te bekijken, inclusief de Azure-resources die u hebt gemaakt. Als u de melding mist, selecteert u het belpictogram in de rechterbenedenhoek om deze opnieuw weer te geven.

De functie in Azure uitvoeren

Ga terug naar het gebied Azure: functions in de zijbalk, vouw uw abonnement uit, uw nieuwe functie-app en functions. Klik met de rechter muisknop (Windows) of CTRL (macOS) op de HttpExample functie en kies functie nu uitvoeren....
In de hoofd tekst van de aanvraag ziet u de waarde van de aanvraag bericht hoofdtekst van { "name": "Azure" } . Druk op ENTER om dit aanvraag bericht naar uw functie te verzenden.
Wanneer de functie wordt uitgevoerd in Azure en een antwoord retourneert, wordt er een melding gegenereerd in Visual Studio code.

Resources opschonen

Wanneer u verder gaat met de volgende stap en een Azure Storage-wachtrijbinding aan uw functie toevoegt, moet u alle resources op dezelfde plaats laten staan, zodat u hiermee verder kunt gaan met wat u al hebt gedaan.

Als dat niet het geval is, kunt u de volgende stappen gebruiken om de functie-app en de bijbehorende resources te verwijderen om te voorkomen dat er verdere kosten in rekening worden gebracht.

Druk in Visual Studio Code op F1 om het opdrachtenpalet te openen. In het opdrachtenpalet zoekt en selecteert u Azure Functions: Open in portal.
Kies uw functie-app en druk op Enter. De functie-app wordt geopend in de Azure-portal.
Selecteer op het tabblad Overzicht de benoemde koppeling naast Resourcegroep.
Bekijk op de pagina Resourcegroep de lijst met opgenomen resources en controleer of dit de resources zijn die u wilt verwijderen.
Selecteer Resourcegroep verwijderen en volg de instructies.

Verwijderen kan enkele minuten duren. Wanneer dit is voltooid, verschijnt een aantal seconden een melding in beeld. U kunt ook het belpictogram boven aan de pagina selecteren om de melding te bekijken.

Zie Kosten voor verbruiksplannen inschatten voor meer informatie over de kosten voor Functions.

Volgende stappen

Meer informatie over aangepaste Azure Functions-handlers