Quels types pouvez-vous transmettre en tant que paramètre à une application C # Azure Function réservée aux administrateurs? What types can you pass as a parameter to an admin-only C # Azure Function app?

Jan 11 2021

Quels types sont autorisés en tant que paramètres pour les applications Azure Function écrites en C # qui ne peuvent être appelées que via le point de terminaison d'administration?

J'ai lu beaucoup de documentation et de code source et je ne connais toujours pas la réponse. Je recherche des références définitives et des explications claires sur ce que cela signifie et pourquoi, ainsi que des exemples sur la façon d'implémenter des fonctions avec d'autres types de paramètres.

Je me demande si l'équipe Azure s'attend à ce que vous acceptiez une chaîne de JSON et que vous l'analysiez vous-même en types appropriés, mais la documentation que j'ai trouvée ne le dit pas.

Contexte supplémentaire

La fonction spécifique sur laquelle je travaille doit être appelée uniquement via l'interface d'administration et n'a donc aucune liaison Http, etc.

[NoAutomaticTrigger]
[FunctionName(nameof(SomeFunctionName))]
public async Task SomeFunctionName(ParameterTypeHere someParameterName)
{
...

Que puis-je mettre à la place ParameterTypeHere?

L'utilisation spécifique que j'ai (cette fois) est que je veux passer quelque chose comme List<Guid>ou Guid[], cela ne me dérange pas si je dois l'envelopper dans une classe ou quelque chose, mais rien de ce que j'ai essayé n'a fonctionné, alors j'ai fini par diviser une chaîne sur virgule et analyser les guides, ce qui semble être une mauvaise solution.

Actuellement, j'ai un paramètre de chaîne et je l'appelle avec:

$ curl -v http://localhost:7071/admin/functions/SomeFunctionName \
  -d '{"input": "699F3073-9BFD-4DA7-9E61-4E6564D032EC,197DA362-C281-4E0F-BB92-8759F7A5B4B4"}' \
  -H "Content-Type:application/json"

Recherche jusqu'à présent

Les choses que j'ai déjà examinées et qui me laissent encore incertain de ce que je peux utiliser au-delà stringpour des entrées plus complexes:

  • Fonctions Azure: type générique comme paramètre d'entrée
    • https://github.com/Azure/Azure-Functions/issues/735
  • Erreur Azure Functions - Impossible de lier le paramètre au type String
  • Impossible de lier le paramètre, car le type de paramètre n'est pas pris en charge par la liaison (HttpTrigger of Azure Functions)
  • Impossible de lier ILogger dans la fonction azure v1
  • https://docs.microsoft.com/en-us/azure/azure-functions/functions-manually-run-non-http
  • https://github.com/Azure/azure-functions-host/blob/dev/src/WebJobs.Script/Binding/Manual/ManualTriggerAttributeBindingProvider.cs#L39
    • https://github.com/Azure/azure-functions-host/blob/9b2fa0f3ea69c41ce819f046213eab4f40a5db5f/src/WebJobs.Script/Binding/StreamValueBinder.cs#L24-L30
    • https://github.com/Azure/azure-functions-host/blob/9b2fa0f3ea69c41ce819f046213eab4f40a5db5f/src/WebJobs.Script/Utility.cs#L245
  • ServiceBusTrigger avec l'argument enqueueTimeUtc échoue lorsqu'il est déclenché via le point de terminaison HTTP

Le nom du paramètre est ignoré et vous devez le transmettre avec le nom " input" quel que soit le nom réel du paramètre. Juste une autre chose sur laquelle trébucher.

Encore plus de contexte

Si vous vous demandez pourquoi vous voudriez une fonction réservée aux administrateurs, c'était pour une tâche ponctuelle exécutée par quelqu'un d'autre qui a accès aux points de terminaison de l'administrateur. Cela semblait être la chose la plus simple qui pouvait fonctionner. Un HttpTriggeraurait été bien, il est apparu que de violer YAGNI.

Réponses

2 RoarS. Jan 11 2021 at 22:56

Il y a quelques semaines, j'ai testé comment convertir une API en utilisant des fonctions avec une attention particulière à DI (non montrée dans l'exemple ci-dessous) et à la validation. Ce n'est peut-être pas une réponse directe à votre question, mais cela montre que des classes de modèle simples peuvent être utilisées.

public class MyRequestModel
{
    [Display(Name = "Message")]
    [Required, MinLength(3)]
    public string Message { get; set; }
}

public static class MyHttpExample
{
    [FunctionName(nameof(MyHttpExample))]
    public static IActionResult Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", Route = "test/{message}")] MyRequestModel req, ILogger log)
    {
        log.LogInformation("C# HTTP trigger function processed a request.");

        var validationResults = new List<ValidationResult>();
        if (!Validator.TryValidateObject(req, new ValidationContext(req, null, null), validationResults, true))
        {
            return new BadRequestObjectResult(validationResults);
        }

        var responseMessage = $"Hello, {req.Message}. This HTTP triggered function executed successfully.";
        return new OkObjectResult(responseMessage);
    }
}

Plus d'informations sur les modèles d'expression de liaison Azure Functions https://docs.microsoft.com/en-us/azure/azure-functions/functions-bindings-expressions-patterns

Lors de la lecture du document ci-dessus, gardez à l'esprit que function.json est généré à partir d'annotations lors de l'utilisation de C #, mais doc montre ce qui est disponible. Généré function.json pour l'exemple ci-dessus:

{
  "generatedBy": "Microsoft.NET.Sdk.Functions-3.0.11",
  "configurationSource": "attributes",
  "bindings": [
    {
      "type": "httpTrigger",
      "route": "test",
      "methods": [
        "get"
      ],
      "authLevel": "function",
      "name": "req"
    }
  ],
  "disabled": false,
  "scriptFile": "../bin/MyFunctions.dll",
  "entryPoint": "MyFunctions.MyHttpExample.Run"
}

Voir également https://stackoverflow.com/a/54489040/14072498