> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Guia de início rápido do CloudScript do PlayFab usando Azure Functions > Escreva o CloudScript do PlayFab com Azure Functions em C# usando o Visual Studio Code e o Unity e, em seguida, vincule as funções a regras, tarefas agendadas ou chamadas do cliente. # Início rápido: escrever um CloudScript do PlayFab usando Azure Functions Neste início rápido, você escreverá um CloudScript usando Azure Functions com o Visual Studio Code, Azure Functions em C# e Unity em C#. Depois de concluir este guia, você poderá vincular seu novo CloudScript a regras e tarefas agendadas ou até chamá-lo a partir do código do cliente. ## Pré-requisitos Há algumas etapas necessárias para começar a usar o CloudScript do PlayFab em C#. * Visite o [Início rápido: criar um projeto do Azure Functions usando o Visual Studio Code](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-csharp?pivots=programming-language-csharp) e volte aqui quando tiver configurado tudo. Os seguintes pré-requisitos são abordados no guia de início rápido: * Uma [conta do Azure](https://azure.microsoft.com/free). A inscrição em uma conta do Azure é gratuita * Uma [assinatura do Azure](https://learn.microsoft.com/en-us/azure/cost-management-billing/manage/create-subscription) * Um recurso de aplicativo de funções configurado no portal do Azure * Para minimizar a latência do seu CloudScript usando Azure Functions, coloque-as nas regiões do Azure *US-West*, *US-West 2* ou *US-West 3*. * **Observação de segurança:** do ponto de vista de segurança, você deve usar um determinado segredo de função somente com o PlayFab e não usá-lo para chamar a mesma função a partir de nenhuma outra origem. * **Observação de segurança:** para funções em fila, você deve configurar uma conta de armazenamento distinta para as filas usadas pelo gatilho de fila. * Uma conta do [PlayFab](https://developer.playfab.com/). As Azure Functions do PlayFab podem usar o runtime do Azure Functions V2 ou posterior e o .NET Core 2 ou posterior. Recomendamos usar a versão mais recente (atualmente, Azure Functions V4 e .NET 6). ## Criar uma Azure Function 1. Crie uma função de exemplo básica "HelloWorld". Você pode ver como fazer isso seguindo o guia [Criar sua primeira função usando o Visual Studio Code](https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-function-vs-code). Para obter um exemplo de código que usa variáveis do PlayFab, consulte a seção [Contexto de função, variáveis e uso dos Server SDKs do PlayFab](#playfabfunctioncontext). O guia "Criar sua primeira função usando o Visual Studio Code" instrui você a definir o nível de autorização da sua Azure Function como `Anonymous`. Isso é feito para simplificar os testes. Em um ambiente de produção, na maioria dos casos, você não deve usar a autorização anônima, pois ela permite que qualquer pessoa chame o ponto de extremidade da sua função. Para proteger adequadamente sua função no ambiente do PlayFab, recomendamos usar a autorização no nível `Function`. 2. Depois de criar e implantar sua função, acesse **Automation** > **Cloud Script** e selecione o botão **Register Function** no canto superior direito da página. Registrar a função do CloudScript 3. Em **Name**, insira um nome amigável para a função. Em **Function URL**, insira a URL do gatilho HTTP da função. A URL pode ser encontrada no menu de contexto do recurso da Azure Function, conforme mostrado na seção "Executar a função no Azure" do [Início rápido: criar uma função no Azure usando o Visual Studio Code](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-csharp?pivots=programming-language-csharp#run-the-function-in-azure). Se sua Azure Function usar autorização no nível `Function`, a URL conterá a chave de autorização. Para obter mais informações sobre a implantação de Azure Functions, consulte [Implantar o Azure Functions usando o Visual Studio Code](https://learn.microsoft.com/azure/azure-functions/functions-develop-vs-code). ## Usar e chamar o CloudScript usando Azure Functions a partir do seu título do PlayFab O código de exemplo deste guia foi escrito em código C# do Unity e C# da Azure Function. Agora que sua função está registrada, você pode chamá-la usando as APIs do PlayFab. ### Chamar sua função usando solicitações HTTP no Visual Studio Code Usando a [extensão REST Client](https://marketplace.visualstudio.com/items?itemName=humao.rest-client), você pode invocar a função dentro do Visual Studio. ```http theme={null} @titleId = ????? # Enter your title ID here @baseUrl = https://{{titleId}}.playfabapi.com ### # @name LoginWithCustomID POST {{baseUrl}}/Client/LoginWithCustomID Accept-Encoding: gzip Content-Type: application/json { "CustomId": "demo", "CreateAccount": true, "TitleId": "{{titleId}}" } @entityToken = {{LoginWithCustomID.response.body.$.data.EntityToken.EntityToken}} @entity = {{LoginWithCustomID.response.body.$.data.EntityToken.Entity}} ### # @name ExecuteFunction POST {{baseUrl}}/CloudScript/ExecuteFunction Accept-Encoding: gzip Content-Type: application/json X-EntityToken: {{entityToken}} { "FunctionName": "HelloWorld" } ### # @name GetObjects POST {{baseUrl}}/Object/GetObjects Accept-Encoding: gzip Content-Type: application/json X-EntityToken: {{entityToken}} { "Entity": {{entity}}, "Objects": ["obj1"] } ``` Depois de colar esse código em um arquivo com a extensão .http no Visual Studio Code, você poderá selecionar *Send request* na função *LoginWithCustomID* para obter o token de entidade de um jogador e, em seguida, em *LoginWithCustomID* para invocar sua função. Invocar *GetObjects* deverá mostrar o objeto que sua Azure Function anexou ao jogador. ### Chamar sua função a partir do Unity Você pode usar este código no Unity para invocar sua função. ```c# theme={null} //This snippet assumes that your game client is already logged into PlayFab. using PlayFab; using PlayFab.CloudScriptModels; private void CallCSharpExecuteFunction() { PlayFabCloudScriptAPI.ExecuteFunction(new ExecuteFunctionRequest() { Entity = new PlayFab.CloudScriptModels.EntityKey() { Id = PlayFabSettings.staticPlayer.EntityId, //Get this from when you logged in, Type = PlayFabSettings.staticPlayer.EntityType, //Get this from when you logged in }, FunctionName = "HelloWorld", //This should be the name of your Azure Function that you created. FunctionParameter = new Dictionary() { { "inputValue", "Test" } }, //This is the data that you would want to pass into your function. GeneratePlayStreamEvent = false //Set this to true if you would like this call to show up in PlayStream }, (ExecuteFunctionResult result) => { if (result.FunctionResultTooLarge ?? false) { Debug.Log("This can happen if you exceed the limit that can be returned from an Azure Function, See PlayFab Limits Page for details."); return; } Debug.Log($"The {result.FunctionName} function took {result.ExecutionTimeMilliseconds} to complete"); Debug.Log($"Result: {result.FunctionResult.ToString()}"); }, (PlayFabError error) => { Debug.Log($"Opps Something went wrong: {error.GenerateErrorReport()}"); }); } ``` ### Contexto, variáveis e Server SDKs do CloudScript do PlayFab Uma vantagem de usar o CloudScript com Azure Functions é que o contexto do evento do PlayStream e do perfil do jogador é passado automaticamente para a Azure Function. Na invocação do CloudScript, você recebe o contexto de acordo com o cenário de invocação da função. Por exemplo, o contexto varia dependendo de a função ser disparada por uma ação do PlayStream ou chamada diretamente pelo cliente. Isso inclui informações como o perfil de entidade em nome do qual o CloudScript foi invocado e, possivelmente, os eventos do PlayStream usados para invocar o CloudScript. 1. Você precisará instalar o SDK do PlayFab por meio do Gerenciador de Pacotes. Para fazer isso, abra o Terminal ou o console CMD no Visual Studio Code e digite: `dotnet add package PlayFabAllSDK` 2. Você precisa incluir o arquivo [CS2AFHelperClasses.cs](https://github.com/PlayFab/PlayFab-Samples/blob/master/Samples/CSharp/AzureFunctions/CS2AFHelperClasses.cs), que contém a implementação de `PlayFab.Samples` 3. A execução de um script pode ocorrer por vários métodos (APIs, tarefas agendadas, eventos do PlayStream, entrada e saída de segmentos). O contexto da execução é importante para implementar seu CloudScript. Consulte o [tutorial Usar modelos de contexto do CloudScript](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/CloudScript-af-context) para obter detalhes sobre como usar o contexto do script. Você pode usar o exemplo HelloWorld como sua primeira Azure Function. Ele invoca uma API de entidade e retorna uma saudação ao jogador autenticado. As APIs de servidor clássicas podem ser invocadas de forma semelhante; no entanto, seria necessário especificar a chave secreta do título para fazer a chamada. A chave secreta pode ser armazenada nas [configurações do aplicativo](https://learn.microsoft.com/en-us/azure/azure-functions/functions-how-to-use-azure-function-app-settings?tabs=portal#settings) e recuperada usando o método `Environment.GetEnvironmentVariable()`. ```c# theme={null} using PlayFab; using PlayFab.Samples; using PlayFab.DataModels; using System.Collections.Generic; using System.Threading.Tasks; namespace PlayFabCS2AFSample.HelloWorld { public static class HelloWorld { [FunctionName("HelloWorld")] public static async Task Run( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { FunctionExecutionContext context = JsonConvert.DeserializeObject>(await req.ReadAsStringAsync()); dynamic args = context.FunctionArgument; var message = $"Hello {context.CallerEntityProfile.Lineage.MasterPlayerAccountId}!"; log.LogInformation(message); dynamic inputValue = null; if (args != null && args["inputValue"] != null) { inputValue = args["inputValue"]; } log.LogDebug($"HelloWorld: {new { input = inputValue} }"); // The profile of the entity specified in the 'ExecuteEntityCloudScript' request. // Defaults to the authenticated entity in the X-EntityToken header. var entityProfile = context.CallerEntityProfile; var api = new PlayFabDataInstanceAPI( new PlayFabApiSettings { TitleId = context.TitleAuthenticationContext.Id }, new PlayFabAuthenticationContext { EntityToken = context.TitleAuthenticationContext.EntityToken } ); var apiResult = await api.SetObjectsAsync( new SetObjectsRequest { Entity = new EntityKey { Id = entityProfile.Entity.Id, Type = entityProfile.Entity.Type }, Objects = new List { new SetObject { ObjectName = "obj1", DataObject = new { foo = "some server computed value", prop1 = "bar" } } } }); return new { messageValue = message }; } } } ``` No exemplo, o `CurrentPlayerId` do chamador está disponível, assim como na nossa implementação tradicional do CloudScript. Os parâmetros que você passa no campo `FunctionParameters` ficam disponíveis em *args*. Porém, ao contrário do exemplo Hello World do guia [Criar sua primeira função usando o Visual Studio Code](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-csharp), os parâmetros são passados no corpo do POST, e não na cadeia de caracteres de consulta. Para chamar a Azure Function HelloWorld a partir de um SDK do PlayFab, use `ExecuteFunction`. ## Azure Functions em regras de automação As Azure Functions também podem ser chamadas criando regras e tarefas agendadas. Isso funciona da mesma forma que o nosso CloudScript padrão. Para criar uma regra ou tarefa agendada, acesse **Automation** > **Rules** ou **Automation** > **Scheduled Tasks**. * Selecione **New Rule** * Insira um nome para a regra * Selecione o tipo de evento que dispara essa regra * Adicione uma ação * Na lista suspensa de ações, selecione **Execute Azure Function** Uma lista das Azure Functions disponíveis que você registrou fica disponível na lista suspensa. Configurar regra para Azure Functions ## Depurar sua Azure Function Com as Azure Functions, agora você tem a opção de depurar seu CloudScript localmente ou no portal do Azure. Para saber mais sobre a depuração no portal, consulte [Depurar o CloudScript usando Azure Functions com o portal do Azure](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-Azure). Para saber como configurar a depuração local, consulte [Depuração local do CloudScript usando Azure Functions](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/local-debugging-for-cloudscript-using-azure-functions). ## Limites de execução As chamadas do CloudScript para Azure Functions têm limites de tempo limite. Se o seu webhook demorar muito para ser executado, a solicitação atingirá o tempo limite no PlayFab. Verifique se o seu código consegue ser executado com rapidez suficiente para permanecer abaixo dos limites de tempo limite. | Origem | Tipo de ação | Limite (segundos) | | - | - | -: | | API do PlayFab | Solicitação HTTP | 10 | | PlayStream V2 | Solicitação HTTP | 10 | | Tarefa agendada | Solicitação HTTP | 4.5 | | PlayStream V1 | Solicitação HTTP | 1 | | Função de fila | Payload de fila | 1 | ## Related topics - [CloudScript do PlayFab usando Azure Functions](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/index.md) - [Depuração local do CloudScript usando Azure Functions](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/local-debugging-for-cloudscript-using-azure-functions.md) - [Modelos de contexto do CloudScript do PlayFab usando Azure Functions](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/CloudScript-af-context.md) - [Depurar Azure Functions do CloudScript no portal do Azure](/pt-BR/services/playfab/live-service-management/service-gateway/automation/cloudscript-af/debugging-with-CloudScript-AF-Azure.md) - [API CloudScript do PlayFab](/pt-BR/services/playfab/api-references/rest/cloudscript/overview.md)