Contexte - Function Compute - Centre de documentation Alibaba Cloud

Cette rubrique décrit l'objet de contexte disponible lors de l'écriture de code dans l'environnement d'exécution C# de Function Compute. Lors de l'exécution de votre fonction, Function Compute transmet un objet de contexte à la méthode du handler. Utilisez cet objet pour accéder aux métadonnées d'invocation, aux identifiants temporaires et aux utilitaires de journalisation, sans coder en dur de valeurs sensibles dans votre code.

Propriétés du contexte

Chaque invocation reçoit un objet de contexte comportant les propriétés suivantes :

RequestId (string) : ID unique de l'invocation en cours. Journalisez cette valeur pour corréler les requêtes lors du dépannage.
Function (IFunctionParameter) : informations de base sur la fonction invoquée (nom, handler, mémoire allouée et délai d'expiration).
Credentials (ICredentials) : identifiants temporaires obtenus par Function Compute via l'endossement de votre rôle lié au service. Valables 36 heures, ils comprennent un AccessKey ID, un AccessKey secret et un jeton de sécurité. Utilisez-les pour accéder à d'autres services Alibaba Cloud tels que Object Storage Service (OSS) sans coder en dur de paire d'AccessKey dans votre fonction. Pour plus d'informations, consultez Accorder à Function Compute les permissions d'accès à d'autres services Alibaba Cloud.
Logger (IFcLogger) : logger encapsulé par Function Compute.
Service (IServiceMeta) : informations de base sur le service auquel appartient la fonction.
OpenTracing

Interface IFcContext

L'interface IFcContext définit l'ensemble des propriétés disponibles dans l'objet de contexte. Pour consulter la définition complète de l'interface, reportez-vous à IFcContext.

public interface IFcContext
{
    /// <summary>
    /// The AliFc request ID associated with the request.
    /// This is the same ID returned to the client that called invoke().
    /// This ID is reused for retries on the same request.
    /// </summary>
    string RequestId { get; }

    /// <summary>
    /// Gets the function parameter interface.
    /// </summary>
    /// <value>The function parameter interface.</value>
    IFunctionParameter FunctionParam {get;}

    /// <summary>
    /// AliFc logger associated with the Context object.
    /// </summary>
    IFcLogger Logger { get; }

    /// <summary>
    /// Gets the credentials interface.
    /// </summary>
    /// <value>The credentials interface.</value>
    ICredentials Credentials {get;}

    /// <summary>
    /// Gets the account identifier.
    /// </summary>
    /// <value>The account identifier.</value>
    string AccountId { get; }

    /// <summary>
    /// Gets the region.
    /// </summary>
    /// <value>The region.</value>
    string Region { get; }

    /// <summary>
    /// Gets the service meta.
    /// </summary>
    /// <value>The service meta.</value>
    IServiceMeta ServiceMeta { get; }
}

Utiliser des identifiants temporaires pour accéder à OSS

L'exemple suivant lit les identifiants temporaires depuis l'objet de contexte pour charger un objet vers OSS. Cette opération nécessite que la politique AliyunOSSFullAccess soit attachée au rôle lié au service. Le rôle recommandé est AliyunFCDefaultRole.

L'utilisation d'une paire d'AccessKey associée à un compte Alibaba Cloud pour effectuer des opérations dans Function Compute présente un risque élevé de sécurité. Privilégiez l'usage d'un utilisateur RAM ou du rôle lié au service. Ne stockez jamais de paire d'AccessKey directement dans le code de votre fonction.

Pour une implémentation de référence, consultez dotnet3-oss.

using System;
using System.IO;
using Aliyun.OSS;
using Aliyun.Serverless.Core;
using Microsoft.Extensions.Logging;

namespace Example
{
    public class OssExample
    {
        public Stream HandleRequest(Stream stream, IFcContext context)
        {
            context.Logger.LogInformation("Handle request: {0}", context.RequestId);

            // The bucket name. Create the bucket before running this function.
            string bucketName = "my-****";

            // The full path of the object to upload.
            string objectName = "exampledir/exampleobject.txt";

            // Use the internal endpoint of the region where the bucket resides.
            // This example uses the internal endpoint for the China (Hangzhou) region.
            string endpoint = "https://oss-cn-hangzhou-internal.aliyuncs.com";

            // Get temporary credentials from the context object.
            // These credentials are issued by the service-linked role configured for the function.
            ICredentials creds = context.Credentials;

            // Create an OssClient instance using the temporary credentials.
            OssClient ossClient =
                new OssClient(endpoint,
                    creds.AccessKeyId,
                    creds.AccessKeySecret,
                    creds.SecurityToken);

            // Upload the input stream as an object.
            ossClient.PutObject(bucketName, objectName, stream);

            // Retrieve the uploaded object and return its content.
            OssObject obj = ossClient.GetObject(bucketName, objectName);
            context.Logger.LogInformation("Put object to OSS success: {0}", obj.ToString());
            return obj.Content;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}