Cvičení – vytvoření funkcí pro aplikaci Azure Functions

9 min

V této lekci vytvoříte a nakonfigurujete funkce v aplikaci Azure Functions pro GETaplikaci , POSTPUTa DELETE koncové body v aplikaci Node.js Express.

Přidání přístupu k datům do funkce GET

První koncový bod rozhraní API jste vytvořili při vytváření aplikace Azure Functions v poslední lekci. Tato funkce se spustí, když je požadován protokol HTTP GET ./vacations Abyste získali dovolenou, musíte aktualizovat často používaný kód tak, aby volal datovou službu.

Otevřete soubor functions/src/functions/getVacations.ts.
Otevřete soubor server/routes/vacation.routes.ts v samostatném okně, abyste viděli oba soubory vedle sebe.
Do getVacations.ts přidejte příkaz vacationService import.
```
import { vacationService } from '../services';
```

V getVacations.ts upravte getVacations funkci tak, aby volala vacationService.

 export async function getVacations(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
     context.log(`Http function processed request for url "${request.url}"`);
     return { jsonBody: vacationService.getVacations() }; // Data access logic within the return object
 };

Mohl bys tam přestat. To je jediný kód, který potřebujete přidat do funkce, abyste získali dovolenou. Měli byste ale také zadat kód pro zpracování chyb a vrácení stavového kódu. Aktualizujte funkci tak, aby používala následující kód.

 export async function getVacations(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
   context.log(`Http function processed request for url "${request.url}"`);

   try {
     const vacations = vacationService.getVacations();  // Data access logic

     if (vacations) {
       return {
         status: 200,
         jsonBody: vacations
       };
     } else {
       return {
         status: 404,
         jsonBody: {
           error: 'No vacations found'
         }
       };
     }      
   } catch (error: unknown) {
     const err = error as Error;
     context.error(`Error listing vacations: ${err.message}`);

     return {
       status: 500,
       jsonBody: {
         error: 'Failed to list vacations'
       }
     };
   }
 };

Uspořádání tras Azure Functions

V programovacím modelu v4 můžete trasy uspořádat několika způsoby. Definici trasy můžete ponechat s obslužnou rutinou trasy v jednom souboru. To je v pořádku pro aplikaci s jedním koncovým bodem. Jako vývojář ve společnosti Tailwind Traders víte, že tato aplikace se bude rozšiřovat na mnoho rozhraní API, která je potřeba uspořádat.

Pokud chcete zahájit organizaci, vytvořte nový ./functions/src/index.ts soubor pro zachycení definic tras.
Přidejte závislost pro aplikaci poskytnutou @azure/functions z balíčku.
```
import { app } from '@azure/functions';
```
Přidejte závislost pro funkci getVacations ze ./functions/getVacations souboru.
```
import { getVacations } from `./functions/getVacations`;
```

Přesuňte definici trasy do ./functions/getVacations souboru index.ts . Aktualizujte pole vlastností metody na GEThodnotu .

app.http('getVacations', {
    methods: ['GET'],
    route: 'vacations',
    authLevel: 'anonymous',
    handler: getVacations
});

Pojmenování funkce a obslužné rutiny

Název getVacations se používá jako první parametr app.http i jako vlastnost v druhém parametru. To může být matoucí a v závislosti na tom, jak se název používá, můžou být různá pravidla pojmenování ve vaší organizaci nebo týmu.

Screenshot of the http definition with the first parameter numbered as one, and the second parameter's handler property numbered as two.

První parametr – název jako řetězec: Hodnota prvního parametru je název funkce, která se zobrazí na webu Azure Portal. Tyto názvy jsou uvedeny alfanumericky na portálu, takže můžete chtít použít konvenci pojmenování, která seskupuje podobné funkce podle účelu, například podle metody, například vacationGet getVacation. Můžete také zvolit jiný případ, například snake_case, kebab-case nebo camelCase.
Druhý parametr – funkce obslužné rutiny: Hodnota druhého parametru je název obslužné rutiny funkce při importu a použití v kódu. Tento název by měl být popisný a odpovídat účelu funkce. Může odpovídat zásadám vytváření názvů, které už máte pro funkce ve svém základu kódu, a může se vynucovat pomocí typických nástrojů pro shodě kódu.

Vytvoření zbývajících funkcí

V aplikaci Node.js Express jsou čtyři koncové body a právě jste vytvořili funkci pro GET koncový bod. Teď vytvořte funkce pro zbývající koncové body trasy.

metoda	Název triggeru HTTP	Postup
`POST`	`postVacation`	`vacations`
`PUT`	`updateVacation`	`vacations/{id}`
`DELETE`	`deleteVacation`	`vacations/{id}`

I když jsou trasy GET a POST stejné. Pomocí PUT parametru a DELETE trasy určíte, kterou dovolenou použít.

Vytvoření funkce HTTP POST

POST Vytvořte funkci, která zpracovává přidání dovolené.

V editoru Visual Studio Code otevřete paletu příkazů pomocí kombinace kláves Ctrl + Shift +P a zadejte Azure Functions: Create Function a stiskněte Enter.
Jako typ vyberte trigger HTTP a jako název postVacation.
Přidejte do souboru příkaz importu vacationService .
```
import { vacationService } from '../services';
```

Často používané postVacation funkce nahraďte následujícím kódem pro přístup k datům a zpracování chyb.

export async function postVacation(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`HTTP function processed request for URL: "${request.url}"`);

    try {
        const vacation = await request.json() as Vacation;

        // Validate the vacation object
        if (!vacation || typeof vacation !== 'object' || !vacation.name || !vacation.description) {
            return {
                status: 400,
                jsonBody: { 
                    error: 'Invalid or missing vacation data.' 
                }
            };
        }

        // Data access logic
        const newVacation = vacationService.addVacation(vacation); 

        // Successfully added the vacation
        return {
            status: 201,
            jsonBody: newVacation
        };
    } catch (error: unknown) {
        const err = error as Error;
        context.error(`Error create vacation: ${err.message}`);

        return {
            status: 500,
            jsonBody: {
                error: 'Failed to create vacation'
            }
        };
    }
}

Ke čtení příchozích dat o dovolené použijete metodu request.json() . Tato metoda vrátí příslib, který se přeloží na data JSON v textu požadavku. Pak pomocí klíčového await slova počkejte, až se příslib vyřeší. Syntaxe as Vacation je kontrolní výraz typu, který říká TypeScriptu, aby s výsledkem zachází jako s objektem Vacation .

const vacation = await request.json() as Vacation;

Přesuňte definici trasy ze souboru postVacation do souboru index.ts . Aktualizujte pole vlastností metody na POSThodnotu .

app.http('post-vacation', {
    methods: ['POST'],
    route: 'vacations',
    authLevel: 'anonymous',
    handler: postVacation
});

Vytvoření funkce HTTP PUT

PUT Vytvořte funkci, která zpracovává přidání dovolené.

V editoru Visual Studio Code otevřete paletu příkazů pomocí kombinace kláves Ctrl + Shift + P a zadejte Azure Functions: Create Function a stiskněte Enter.
Jako typ vyberte trigger HTTP a jako název aktualizujteVacation.
Přidejte do souboru příkaz importu vacationService .
```
import { vacationService } from '../services';
```

Často používané updateVacation funkce nahraďte následujícím kódem pro přístup k datům a zpracování chyb.

export async function updateVacation(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  try {
    const id = request.params.id;
    const { name, description } = await request.json() as Vacation;

    // Data access logic
    const updatedVacation = vacationService.updateVacation({ id, name, description });

    if (updatedVacation !== undefined) {
      return {
        status: 200,
        jsonBody: {
          updatedVacation
        }
      };
    } else {
      return {
        status: 404,
        jsonBody: {
          error: `Vacation with ID ${id} not found`
        }
      };
    }
  } catch (error: unknown) {
    const err = error as Error;
    context.error(`Error updating vacation: ${err.message}`);

    return {
      status: 500,
      jsonBody: {
        error: 'Failed to update vacation'
      }
    };
  }
};

Vlastnost request.params.id se používá k získání ID dovolené z adresy URL. Metoda request.json() se používá k získání dat o dovolené z textu požadavku. Syntaxe as Vacation je kontrolní výraz typu, který říká TypeScriptu, aby s výsledkem zachází jako s objektem Vacation .

Přesuňte definici trasy ze souboru putVacation do souboru index.ts . Aktualizujte pole vlastností metody na PUThodnotu .

app.http('updateVacation', {
    methods: ['PUT'],
    route: 'vacations/{id}',
    authLevel: 'anonymous',
    handler: updateVacation
});

Vytvoření funkce HTTP DELETE

DELETE Vytvořte funkci, která zpracovává přidání dovolené.

V editoru Visual Studio Code otevřete paletu příkazů pomocí kombinace kláves Ctrl + Shift + P a zadejte Azure Functions: Create Function a stiskněte Enter.
Jako typ vyberte trigger HTTP a jako název odstraňteVacation.
Přidejte do souboru import služby vacationService.
```
import { vacationService } from '../services';
```

Často používané deleteVacation funkce nahraďte následujícím kódem pro přístup k datům a zpracování chyb.

export async function deleteVacation(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  context.log(`Http function processed request for url "${request.url}"`);

  try {

    const id = request.params.id;

    if (!id) {
      return {
        status: 400,
        jsonBody: {
          error: 'ID parameter is required'
        }
      };
    }

    const deletedVacation = vacationService.deleteVacation(id);

    if (deletedVacation) {
      return {
        status: 204,
        jsonBody: {
          deleteVacation
        }
      };
    } else {
      return {
        status: 404,
        jsonBody: {
          error: `Vacation with ID ${id} not found`
        }
      };
    }
  } catch (error: unknown) {
    const err = error as Error;
    context.error(`Error deleting vacation: ${err.message}`);

    return {
      status: 500,
      jsonBody: {
        error: 'Failed to delete vacation'
      }
    };
  }
};

Vlastnost request.params.id se používá k získání ID dovolené z adresy URL.

Přesuňte definici trasy ze souboru deleteVacation do souboru index.ts . Aktualizujte pole vlastností metody na DELETEhodnotu .

app.http('deleteVacation', {
    methods: ['DELETE'],
    route: 'vacations/{id}',
    authLevel: 'anonymous',
    handler: deleteVacation
});

Přejděte k další lekci a zkontrolujte aplikaci Azure Functions, kterou jste vytvořili.