Azure Functions JavaScript 개발자 가이드Azure Functions JavaScript developer guide

이 가이드에는 JavaScript로 Azure Functions를 작성하는 복잡성에 대한 정보가 포함되어 있습니다.This guide contains information about the intricacies of writing Azure Functions with JavaScript.

JavaScript 함수는 트리거될 때 실행되는 내보낸 function입니다(트리거는 function.json에서 구성됨).A JavaScript function is an exported function that executes when triggered (triggers are configured in function.json). 모든 함수에 전달 된 첫 번째 인수는 context 수신 및 송신 데이터 바인딩, 로깅 및 런타임과 통신에 사용 되는 개체입니다.The first argument passed to every function is a context object, which is used for receiving and sending binding data, logging, and communicating with the runtime.

이 문서에서는 Azure Functions 개발자 참조를 이미 읽었다고 가정합니다.This article assumes that you have already read the Azure Functions developer reference. 첫 번째를 만드는 함수 빠른 시작을 완료 함수를 사용 하 여 Visual Studio Code 하거나 포털에서합니다.Complete the Functions quickstart to create your first function, using Visual Studio Code or in the portal.

이 문서에서는 TypeScript 앱 개발합니다.This article also supports TypeScript app development.

폴더 구조Folder structure

JavaScript 프로젝트에 필요한 폴더 구조는 다음과 같습니다.The required folder structure for a JavaScript project looks like the following. 이 기본값은 변경 가능합니다.This default can be changed. 자세한 내용은 아래의 scriptFile 섹션을 참조하세요.For more information, see the scriptFile section below.

FunctionsProject
 | - MyFirstFunction
 | | - index.js
 | | - function.json
 | - MySecondFunction
 | | - index.js
 | | - function.json
 | - SharedCode
 | | - myFirstHelperFunction.js
 | | - mySecondHelperFunction.js
 | - node_modules
 | - host.json
 | - package.json
 | - extensions.csproj

프로젝트 루트에는 함수 앱을 구성하는 데 사용할 수 있는 공유 host.json 파일이 있습니다.At the root of the project, there's a shared host.json file that can be used to configure the function app. 각 함수에는 자체 코드 파일(.js)과 바인딩 구성 파일(function.json)이 있는 폴더가 있습니다.Each function has a folder with its own code file (.js) and binding configuration file (function.json). function.json의 부모 디렉터리 이름은 항상 함수의 이름입니다.The name of function.json's parent directory is always the name of your function.

Functions 런타임의 버전 2.x에 필요한 바인딩 확장은 extensions.csproj 파일에 정의되어 있고 실제 라이브러리 파일은 bin 폴더에 있습니다.The binding extensions required in version 2.x of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. 로컬에서 개발할 때는 바인딩 확장을 등록해야 합니다.When developing locally, you must register binding extensions. Azure Portal에서 함수를 개발할 때 이 등록이 자동으로 수행됩니다.When developing functions in the Azure portal, this registration is done for you.

함수 내보내기Exporting a function

JavaScript 함수는 module.exports(또는 exports)를 통해 내보내야 합니다.JavaScript functions must be exported via module.exports (or exports). 내보낸 함수는 트리거될 때 실행되는 JavaScript 함수여야 합니다.Your exported function should be a JavaScript function that executes when triggered.

기본적으로 Functions 런타임은 index.js에서 함수를 찾습니다. 여기서 index.js는 해당하는 function.json과 동일한 부모 디렉터리를 공유합니다.By default, the Functions runtime looks for your function in index.js, where index.js shares the same parent directory as its corresponding function.json. 기본적인 경우 내보낸 함수는 run 또는 index라는 해당 파일 또는 내보내기의 유일한 내보내기여야 합니다.In the default case, your exported function should be the only export from its file or the export named run or index. 함수의 파일 위치 및 내보내기 이름을 구성하려면 아래에서 함수의 진입점 구성에 대한 내용을 읽어보세요.To configure the file location and export name of your function, read about configuring your function's entry point below.

내보낸 함수는 실행에서 인수의 수로 전달됩니다.Your exported function is passed a number of arguments on execution. 사용하는 첫 번째 인수는 항상 context 개체입니다.The first argument it takes is always a context object. 함수가 동기화되면(Promise를 반환하지 않음) 올바른 사용을 위해 context.done을 호출해야 할 때 context 개체를 전달해야 합니다.If your function is synchronous (does not return a Promise), you must pass the context object, as calling context.done is required for correct use.

// You should include context, other arguments are optional
module.exports = function(context, myTrigger, myInput, myOtherInput) {
    // function logic goes here :)
    context.done();
};

비동기 함수 내보내기Exporting an async function

Functions 런타임 2.x 버전에서 async function 선언 또는 일반 JavaScript Promises를 사용할 때 함수가 완료되었음을 나타내는 context.done 콜백을 명시적으로 호출할 필요가 없습니다.When using the async function declaration or plain JavaScript Promises in version 2.x of the Functions runtime, you do not need to explicitly call the context.done callback to signal that your function has completed. 내보낸 비동기 함수/Promise가 완료되면 함수가 완료됩니다.Your function completes when the exported async function/Promise completes. 버전 1.x 런타임을 대상으로 하는 함수의 경우 코드 실행이 완료되면 context.done을 호출해야 합니다.For functions targeting the version 1.x runtime, you must still call context.done when your code is done executing.

다음 예제는 트리거되었으며 즉시 실행을 완료한다고 기록하는 간단한 함수입니다.The following example is a simple function that logs that it was triggered and immediately completes execution.

module.exports = async function (context) {
    context.log('JavaScript trigger function processed a request.');
};

비동기 함수를 내보낼 때는 return 값을 사용하도록 출력 바인딩을 구성할 수도 있습니다.When exporting an async function, you can also configure an output binding to take the return value. 하나의 출력 바인딩이 있는 경우에 권장됩니다.This is recommended if you only have one output binding.

return을 사용하여 출력을 할당하려면 function.json에서 name 속성을 $return으로 변경합니다.To assign an output using return, change the name property to $return in function.json.

{
  "type": "http",
  "direction": "out",
  "name": "$return"
}

이 경우에 함수는 다음 예제와 유사합니다.In this case, your function should look like the following example:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger function processed a request.');
    // You can call and await an async method here
    return {
        body: "Hello, world!"
    };
}

바인딩Bindings

JavaScript에서 바인딩은 함수의 function.json에서 구성되고 정의됩니다.In JavaScript, bindings are configured and defined in a function's function.json. Functions는 다양한 방법으로 바인딩과 상호 작용합니다.Functions interact with bindings a number of ways.

입력Inputs

입력은 Azure Functions에서 두 가지 범주로 나뉩니다. 즉 하나는 트리거 입력이고, 다른 하나는 추가 입력입니다.Input are divided into two categories in Azure Functions: one is the trigger input and the other is the additional input. 트리거 및 기타 입력 바인딩(direction === "in"의 바인딩)은 다음과 같은 세 가지 방법으로 함수에서 읽을 수 있습니다.Trigger and other input bindings (bindings of direction === "in") can be read by a function in three ways:

  • [권장] 함수에 전달된 매개 변수입니다.[Recommended] As parameters passed to your function. 이러한 항목은 function.json에 정의된 순서대로 함수에 전달됩니다.They are passed to the function in the same order that they are defined in function.json. 합니다 name 에 정의 된 속성 function.json 해야 하지만, 매개 변수의 이름과 일치 하도록 필요 하지 않습니다.The name property defined in function.json does not need to match the name of your parameter, although it should.

    module.exports = async function(context, myTrigger, myInput, myOtherInput) { ... };
    
  • context.bindings 개체의 모든 멤버입니다.As members of the context.bindings object. 각 멤버는 function.json에서 정의된 name 속성으로 이름이 지정됩니다.Each member is named by the name property defined in function.json.

    module.exports = async function(context) { 
        context.log("This is myTrigger: " + context.bindings.myTrigger);
        context.log("This is myInput: " + context.bindings.myInput);
        context.log("This is myOtherInput: " + context.bindings.myOtherInput);
    };
    
  • 입력으로 JavaScriptarguments 개체를 사용합니다.As inputs using the JavaScript arguments object. 그러면 기본적으로 입력 매개 변수로 전달하는 것과 동일하지만 동적으로 입력을 처리할 수 있습니다.This is essentially the same as passing inputs as parameters, but allows you to dynamically handle inputs.

    module.exports = async function(context) { 
        context.log("This is myTrigger: " + arguments[1]);
        context.log("This is myInput: " + arguments[2]);
        context.log("This is myOtherInput: " + arguments[3]);
    };
    

outputsOutputs

출력(direction === "out"의 바인딩)은 다양한 방법으로 함수에서 작성될 수 있습니다.Outputs (bindings of direction === "out") can be written to by a function in a number of ways. 모든 경우에 function.json에 정의된 대로 바인딩의 name 속성은 함수에서 작성된 개체 멤버의 이름에 해당합니다.In all cases, the name property of the binding as defined in function.json corresponds to the name of the object member written to in your function.

(이러한 메서드를 결합 하지 마세요) 다음 방법 중 하나로 출력 바인딩에 데이터를 할당할 수 있습니다.You can assign data to output bindings in one of the following ways (don't combine these methods):

  • [여러 출력에 대한 권장] 개체를 반환합니다.[Recommended for multiple outputs] Returning an object. 함수를 반환 하는 비동기/프라미스를 사용 하는 경우에 할당 된 출력 데이터를 사용 하 여 개체를 반환할 수 있습니다.If you are using an async/Promise returning function, you can return an object with assigned output data. 아래 예제에서 출력 바인딩의 이름은 function.json에서 "httpResponse" 및 "queueOutput"으로 지정됩니다.In the example below, the output bindings are named "httpResponse" and "queueOutput" in function.json.

    module.exports = async function(context) {
        let retMsg = 'Hello, world!';
        return {
            httpResponse: {
                body: retMsg
            },
            queueOutput: retMsg
        };
    };
    

    동기 함수를 사용하는 경우 context.done을 사용하여 이 개체를 반환할 수 있습니다(예제 참조).If you are using a synchronous function, you can return this object using context.done (see example).

  • [단일 출력에 대한 권장] 직접 값을 반환하고 $return 바인딩 이름을 사용합니다.[Recommended for single output] Returning a value directly and using the $return binding name. 함수를 반환하는 비동기/Promise에서 작동합니다.This only works for async/Promise returning functions. 비동기 함수 내보내기에서 예제를 참조하세요.See example in exporting an async function.

  • context.bindings에 대한 값을 할당합니다. context.bindings에 직접 값을 할당할 수 있습니다.Assigning values to context.bindings You can assign values directly to context.bindings.

    module.exports = async function(context) {
        let retMsg = 'Hello, world!';
        context.bindings.httpResponse = {
            body: retMsg
        };
        context.bindings.queueOutput = retMsg;
        return;
    };
    

바인딩 데이터 형식Bindings data type

입력 바인딩에 대한 데이터 형식을 정의하려면 바인딩 정의에서 dataType 속성을 사용합니다.To define the data type for an input binding, use the dataType property in the binding definition. 예를 들어 이진 형식의 HTTP 요청 내용을 읽으려면 binary 형식을 사용합니다.For example, to read the content of an HTTP request in binary format, use the type binary:

{
    "type": "httpTrigger",
    "name": "req",
    "direction": "in",
    "dataType": "binary"
}

dataType에 대한 옵션은 binary, streamstring입니다.Options for dataType are: binary, stream, and string.

context 개체context object

런타임은 함수로 데이터를 전달하거나 전달받으며 사용자가 런타임과 통신할 수 있도록 하는 context 개체를 사용합니다.The runtime uses a context object to pass data to and from your function and to let you communicate with the runtime. 내보낸 함수가 동기화된 경우 컨텍스트 개체는 바인딩에서 데이터를 읽고 설정하고, 로그를 작성하고, context.done 콜백을 사용하는 데 사용될 수 있습니다.The context object can be used for reading and setting data from bindings, writing logs, and using the context.done callback when your exported function is synchronous.

context 개체는 항상 함수의 첫 번째 매개 변수입니다.The context object is always the first parameter to a function. context.donecontext.log와 같은 중요한 메서드가 있으므로 포함되어야 합니다.It should be included because it has important methods such as context.done and context.log. 원하는 개체 이름(예: ctx 또는 c)을 지정할 수 있습니다.You can name the object whatever you would like (for example, ctx or c).

// You must include a context, but other arguments are optional
module.exports = function(ctx) {
    // function logic goes here :)
    ctx.done();
};

context.bindings 속성context.bindings property

context.bindings

읽기 또는 바인딩 데이터 할당에 사용 되는 명명 된 개체를 반환 합니다.Returns a named object that is used to read or assign binding data. 입력 및 트리거 데이터 바인딩 속성에서 참조 하 여 액세스할 수 있습니다 context.bindings합니다.Input and trigger binding data can be accessed by reading properties on context.bindings. 데이터를 추가 하 여 출력 바인딩은 데이터를 할당할 수 있습니다. context.bindingsOutput binding data can be assigned by adding data to context.bindings

예를 들어 function.json의 다음 바인딩 정의를 통해 context.bindings.myInput에서 큐의 콘텐츠에 액세스하고 context.bindings.myOutput을 사용하여 출력을 큐에 할당할 수 있습니다.For example, the following binding definitions in your function.json let you access the contents of a queue from context.bindings.myInput and assign outputs to a queue using context.bindings.myOutput.

{
    "type":"queue",
    "direction":"in",
    "name":"myInput"
    ...
},
{
    "type":"queue",
    "direction":"out",
    "name":"myOutput"
    ...
}
// myInput contains the input data, which may have properties such as "name"
var author = context.bindings.myInput.name;
// Similarly, you can set your output data
context.bindings.myOutput = { 
        some_text: 'hello world', 
        a_number: 1 };

context.binding 개체 대신 context.done 메서드를 사용하여 출력 바인딩 데이터를 정의하도록 선택할 수 있습니다(아래 참조).You can choose to define output binding data using the context.done method instead of the context.binding object (see below).

context.bindingData propertycontext.bindingData property

context.bindingData

트리거 메타데이터 및 함수 호출 데이터(invocationId, sys.methodName, sys.utcNow, sys.randGuid)를 포함하는 명명된 개체를 반환합니다.Returns a named object that contains trigger metadata and function invocation data (invocationId, sys.methodName, sys.utcNow, sys.randGuid). 트리거 메타데이터의 예제는 event hubs example을 참조하세요.For an example of trigger metadata, see this event hubs example.

context.done 메서드context.done method

context.done([err],[propertyBag])

런타임에서는 코드가 완료되었음을 알 수 있습니다.Lets the runtime know that your code has completed. 함수가 async function 선언을 사용하는 경우 context.done()을 사용할 필요가 없습니다.When your function uses the async function declaration, you do not need to use context.done(). context.done 콜백을 암시적으로 호출합니다.The context.done callback is implicitly called. 비동기 함수는 Node 8 이상 버전에서 지원되며 Functions 런타임의 2.x 버전이 필요합니다.Async functions are available in Node 8 or a later version, which requires version 2.x of the Functions runtime.

함수가 비동기 함수가 아닌 경우 함수가 완료됐음을 런타임에 알리려면 context.done반드시 호출해야 합니다.If your function is not an async function, you must call context.done to inform the runtime that your function is complete. 실행이 누락된 경우 시간 초과가 발생합니다.The execution times out if it is missing.

context.done 메서드를 사용하면 출력 바인딩 데이터가 포함된 JSON 개체와 런타임에 사용자 정의 오류를 다시 전달할 수 있습니다.The context.done method allows you to pass back both a user-defined error to the runtime and a JSON object containing output binding data. context.done에 전달된 속성은 context.bindings 개체에 설정된 내용을 덮어씁니다.Properties passed to context.done overwrite anything set on the context.bindings object.

// Even though we set myOutput to have:
//  -> text: 'hello world', number: 123
context.bindings.myOutput = { text: 'hello world', number: 123 };
// If we pass an object to the done function...
context.done(null, { myOutput: { text: 'hello there, world', noNumber: true }});
// the done method overwrites the myOutput binding to be: 
//  -> text: 'hello there, world', noNumber: true

context.log 메서드context.log method

context.log(message)

기본 추적 수준에서 스트리밍 함수 로그에 기록할 수 있습니다.Allows you to write to the streaming function logs at the default trace level. context.log에 다른 추적 수준에서 함수 로그를 작성할 수 있는 추가 로깅 메서드가 제공됩니다.On context.log, additional logging methods are available that let you write function logs at other trace levels:

방법Method 설명Description
error(message)error(message) 오류 수준 로깅 또는 더 낮은 수준의 로깅에 씁니다.Writes to error level logging, or lower.
warn(message)warn(message) 경고 수준 로깅 또는 더 낮은 수준의 로깅에 씁니다.Writes to warning level logging, or lower.
info(message)info(message) 정보 수준 로깅 또는 더 낮은 수준의 로깅에 씁니다.Writes to info level logging, or lower.
verbose(message)verbose(message) 자세한 정보 표시 수준 로깅에 씁니다.Writes to verbose level logging.

다음 예제는 경고 추적 수준에서 로그를 기록합니다.The following example writes a log at the warning trace level:

context.log.warn("Something has happened."); 

host.json 파일에 로깅에 대한 추적 수준 임계값을 구성할 수 있습니다.You can configure the trace-level threshold for logging in the host.json file. 로그 작성에 대한 자세한 내용은 아래에서 추적 출력 작성을 참조하세요.For more information on writing logs, see writing trace outputs below.

함수 로그 보기 및 쿼리에 대해 자세히 알아보려면 Azure Functions 모니터링을 읽어보세요.Read monitoring Azure Functions to learn more about viewing and querying function logs.

콘솔에 추적 출력 작성Writing trace output to the console

Functions에서 context.log 메서드를 사용하여 추적 출력을 콘솔에 씁니다.In Functions, you use the context.log methods to write trace output to the console. Functions v2.x에서 console.log를 사용하는 추적 출력은 Function App 수준에서 캡처됩니다.In Functions v2.x, trace outputs using console.log are captured at the Function App level. 이 즉, 출력에서 console.log 특정 함수 호출에 연결 되지 않습니다 및 특정 함수의 로그에 표시 되지 않습니다.This means that outputs from console.log are not tied to a specific function invocation and aren't displayed in a specific function's logs. 하지만 Application Insights로 전파됩니다.They do, however, propagate to Application Insights. Functions v1.x에서는 console.log를 사용하여 콘솔에 쓸 수 없습니다.In Functions v1.x, you cannot use console.log to write to the console.

context.log()를 호출하면 메시지를 정보 추적 수준인 기본 추적 수준에서 콘솔에 씁니다.When you call context.log(), your message is written to the console at the default trace level, which is the info trace level. 다음 코드는 정보 추적 수준에서 콘솔에 씁니다.The following code writes to the console at the info trace level:

context.log({hello: 'world'});  

이 코드는 위의 코드와 같습니다.This code is equivalent to the code above:

context.log.info({hello: 'world'});  

이 코드는 오류 수준에서 콘솔에 기록합니다.This code writes to the console at the error level:

context.log.error("An error has occurred.");  

error(오류)가 가장 높은 추적 수준이므로 로깅이 활성화되어 있는 한 이 추적은 모든 추적 수준에서 출력에 씁니다.Because error is the highest trace level, this trace is written to the output at all trace levels as long as logging is enabled.

모든 context.log 메서드는 Node.js util.format 메서드에서 지원하는 것과 동일한 매개 변수 형식을 지원합니다.All context.log methods support the same parameter format that's supported by the Node.js util.format method. 기본 추적 수준을 사용하여 함수 로그를 작성하는 다음 코드를 살펴보세요.Consider the following code, which writes function logs by using the default trace level:

context.log('Node.js HTTP trigger function processed a request. RequestUri=' + req.originalUrl);
context.log('Request Headers = ' + JSON.stringify(req.headers));

또한 동일한 코드를 다음과 같은 형식으로 작성할 수도 있습니다.You can also write the same code in the following format:

context.log('Node.js HTTP trigger function processed a request. RequestUri=%s', req.originalUrl);
context.log('Request Headers = ', JSON.stringify(req.headers));

콘솔 로깅에 대한 추적 수준 구성Configure the trace level for console logging

Functions 1.x에서는 콘솔에 작성할 임계값 추적 수준을 정의할 수 있으므로 추적이 함수에서 콘솔에 작성되는 방식을 쉽게 제어할 수 있습니다.Functions 1.x lets you define the threshold trace level for writing to the console, which makes it easy to control the way traces are written to the console from your function. 콘솔에 기록되는 모든 추적에 대한 임계값을 설정하려면 host.json 파일의 tracing.consoleLevel 속성을 사용합니다.To set the threshold for all traces written to the console, use the tracing.consoleLevel property in the host.json file. 이 설정은 함수 앱의 모든 함수에 적용됩니다.This setting applies to all functions in your function app. 다음 예제에서는 추적 임계값을 설정하여 자세한 정보 표시 로깅을 사용하도록 설정합니다.The following example sets the trace threshold to enable verbose logging:

{
    "tracing": {
        "consoleLevel": "verbose"
    }
}  

consoleLevel의 값은 context.log 메서드의 이름에 해당합니다.Values of consoleLevel correspond to the names of the context.log methods. 콘솔에 대한 모든 추적 로깅을 사용하지 않으려면 consoleLevel을 _off_로 설정합니다.To disable all trace logging to the console, set consoleLevel to off. 자세한 내용은 host.json 참조를 참조하세요.For more information, see host.json reference.

HTTP 트리거 및 바인딩HTTP triggers and bindings

HTTP, 웹후크 트리거 및 HTTP 출력 바인딩은 요청 및 응답 개체를 사용하여 HTTP 메시지를 나타냅니다.HTTP and webhook triggers and HTTP output bindings use request and response objects to represent the HTTP messaging.

요청 개체Request object

context.req(요청) 개체의 속성은 다음과 같습니다.The context.req (request) object has the following properties:

자산Property 설명Description
bodybody 요청의 본문을 포함하는 개체입니다.An object that contains the body of the request.
headersheaders 요청 헤더를 포함하는 개체입니다.An object that contains the request headers.
methodmethod 요청의 HTTP 메서드입니다.The HTTP method of the request.
originalUrloriginalUrl 요청의 URL입니다.The URL of the request.
paramsparams 요청의 라우팅 매개 변수를 포함하는 개체입니다.An object that contains the routing parameters of the request.
queryquery 쿼리 매개 변수를 포함하는 개체입니다.An object that contains the query parameters.
rawBodyrawBody 문자열 형식의 메시지 본문입니다.The body of the message as a string.

응답 개체Response object

context.res(응답) 개체의 속성은 다음과 같습니다.The context.res (response) object has the following properties:

자산Property 설명Description
bodybody 응답의 본문을 포함하는 개체입니다.An object that contains the body of the response.
headersheaders 응답 헤더를 포함하는 개체입니다.An object that contains the response headers.
isRawisRaw 응답에 대한 서식 지정을 건너뜀을 나타냅니다.Indicates that formatting is skipped for the response.
statusstatus 응답의 HTTP 상태 코드입니다.The HTTP status code of the response.

요청 및 응답 액세스Accessing the request and response

HTTP 트리거로 작업할 때 여러 가지 방법으로 HTTP 요청 및 응답 개체에 액세스할 수 있습니다.When you work with HTTP triggers, you can access the HTTP request and response objects in a number of ways:

  • context 개체의 reqres 속성에서.From req and res properties on the context object. 이러한 방식으로 전체 context.bindings.name 패턴을 사용하지 않고 대신 기존 패턴을 사용하여 context 개체에서 HTTP 데이터에 액세스할 수 있습니다.In this way, you can use the conventional pattern to access HTTP data from the context object, instead of having to use the full context.bindings.name pattern. 다음 예제에서는 contextreqres 개체에 액세스하는 방법을 보여 줍니다.The following example shows how to access the req and res objects on the context:

    // You can access your http request off the context ...
    if(context.req.body.emoji === ':pizza:') context.log('Yay!');
    // and also set your http response
    context.res = { status: 202, body: 'You successfully ordered more coffee!' }; 
    
  • 명명된 입출력 바인딩에서.From the named input and output bindings. 이러한 방식으로 HTTP 트리거와 바인딩은 다른 바인딩과 동일하게 작동합니다.In this way, the HTTP trigger and bindings work the same as any other binding. 다음 예제에서는 명명된 response 바인딩을 사용하여 응답 개체를 설정합니다.The following example sets the response object by using a named response binding:

    {
        "type": "http",
        "direction": "out",
        "name": "response"
    }
    
    context.bindings.response = { status: 201, body: "Insert succeeded." };
    
  • [응답 전용] context.res.send(body?: any)를 호출합니다.[Response only] By calling context.res.send(body?: any). HTTP 응답은 입력 body를 응답 본문으로 작성합니다.An HTTP response is created with input body as the response body. context.done()은 암시적으로 호출됩니다.context.done() is implicitly called.

  • [응답 전용] context.done()를 호출합니다.[Response only] By calling context.done(). context.done() 메서드에 전달되는 응답을 반환하는 특별한 종류의 HTTP 바인딩이 있습니다.A special kind of HTTP binding returns the response that is passed to the context.done() method. 다음 HTTP 출력 바인딩은 $return 출력 매개 변수를 정의합니다.The following HTTP output binding defines a $return output parameter:

    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
    
     // Define a valid response object.
    res = { status: 201, body: "Insert succeeded." };
    context.done(null, res);   
    

노드 버전Node version

다음 표에서는 주 버전의 Functions 런타임 각각에서 사용되는 Node.js 버전을 보여 줍니다.The following table shows the Node.js version used by each major version of the Functions runtime:

Functions 버전Functions version Node.js 버전Node.js version
1.x1.x 6.11.2(런타임에 의해 잠김)6.11.2 (locked by the runtime)
2.x2.x 활성 LTS 및 짝수 번호의 현재 Node.js 버전(8.11.1 및 10.14.1 권장).Active LTS and even-numbered Current Node.js versions (8.11.1 and 10.14.1 recommended). WEBSITE_NODE_DEFAULT_VERSION 앱 설정을 사용하여 버전을 설정합니다.Set the version by using the WEBSITE_NODE_DEFAULT_VERSION app setting.

위의 앱 설정을 확인하거나 함수에서 process.version을 인쇄하여 런타임에 사용 중인 현재 버전을 확인할 수 있습니다.You can see the current version that the runtime is using by checking the above app setting or by printing process.version from any function.

종속성 관리Dependency management

아래 예제와 같이 JavaScript 코드에서 커뮤니티 라이브러리를 사용하려면, Azure의 Function App에 모든 종속성이 설치되어 있는지 확인해야 합니다.In order to use community libraries in your JavaScript code, as is shown in the below example, you need to ensure that all dependencies are installed on your Function App in Azure.

// Import the underscore.js library
var _ = require('underscore');
var version = process.version; // version === 'v6.5.0'

module.exports = function(context) {
    // Using our imported underscore.js library
    var matched_names = _
        .where(context.bindings.myInput.names, {first: 'Carla'});

참고

Function App의 루트에 package.json 파일을 정의해야 합니다.You should define a package.json file at the root of your Function App. 파일을 정의하면 앱의 모든 함수에서 동일한 캐시된 패키지를 공유할 수 있으므로 최상의 성능을 제공합니다.Defining the file lets all functions in the app share the same cached packages, which gives the best performance. 버전 충돌이 발생하는 경우 특정 함수의 폴더에 package.json 파일을 추가하여 이 충돌을 해결할 수 있습니다.If a version conflict arises, you can resolve it by adding a package.json file in the folder of a specific function.

원본 제어에서 Function App을 배포할 때 리포지토리에 있는 모든 package.json 파일이 배포 중에 폴더의 npm install을 트리거합니다.When deploying Function Apps from source control, any package.json file present in your repo, will trigger an npm install in its folder during deployment. 그러나 포털 또는 CLI를 통해 배포할 때는 수동으로 패키지를 설치해야 합니다.But when deploying via the Portal or CLI, you will have to manually install the packages.

Function App에 패키지를 설치하는 방법에는 두 가지가 있습니다.There are two ways to install packages on your Function App:

종속성을 사용하여 배포Deploying with Dependencies

  1. npm install을 실행하여 모든 필수 패키지를 로컬에 설치합니다.Install all requisite packages locally by running npm install.

  2. 코드를 배포하고 node_modules 폴더가 배포에 포함되어 있는지 확인합니다.Deploy your code, and ensure that the node_modules folder is included in the deployment.

Kudu 사용Using Kudu

  1. https://<function_app_name>.scm.azurewebsites.net로 이동합니다.Go to https://<function_app_name>.scm.azurewebsites.net.

  2. 디버그 콘솔 > CMD를 클릭합니다.Click Debug Console > CMD.

  3. D:\home\site\wwwroot로 이동한 다음 package.json 파일을 페이지 위쪽의 wwwroot 폴더로 끌어갑니다.Go to D:\home\site\wwwroot, and then drag your package.json file to the wwwroot folder at the top half of the page.
    다른 방법으로 함수 앱에 파일을 업로드할 수도 있습니다.You can upload files to your function app in other ways also. 자세한 내용은 함수 앱 파일을 업데이트하는 방법을 참조하세요.For more information, see How to update function app files.

  4. package.json 파일을 업로드한 후 Kudu 원격 실행 콘솔에서 npm install 명령을 실행합니다.After the package.json file is uploaded, run the npm install command in the Kudu remote execution console.
    이 작업은 package.json 파일에 표시된 패키지를 다운로드하고 함수 앱을 다시 시작합니다.This action downloads the packages indicated in the package.json file and restarts the function app.

환경 변수Environment variables

Functions에서 앱 설정(예: 서비스 연결 문자열)은 실행 중에 환경 변수로 노출됩니다.In Functions, app settings, such as service connection strings, are exposed as environment variables during execution. GetEnvironmentVariable 함수에 표시된 대로 process.env를 사용하여 이러한 설정에 액세스할 수 있습니다.You can access these settings using process.env, as shown here in the GetEnvironmentVariable function:

module.exports = function (context, myTimer) {
    var timeStamp = new Date().toISOString();

    context.log('Node.js timer trigger function ran!', timeStamp);
    context.log(GetEnvironmentVariable("AzureWebJobsStorage"));
    context.log(GetEnvironmentVariable("WEBSITE_SITE_NAME"));

    context.done();
};

function GetEnvironmentVariable(name)
{
    return name + ": " + process.env[name];
}

함수 앱 설정을 추가, 업데이트 및 삭제할 수 있는 여러 가지 방법이 있습니다.There are several ways that you can add, update, and delete function app settings:

로컬로 실행하는 경우 앱 설정은 local.settings.json 프로젝트 파일에서 읽습니다.When running locally, app settings are read from the local.settings.json project file.

함수 진입점 구성Configure function entry point

function.json 속성과 scriptFileentryPoint는 내보낸 함수의 위치와 이름을 구성하는 데 사용할 수 있습니다.The function.json properties scriptFile and entryPoint can be used to configure the location and name of your exported function. 이러한 속성은 JavaScript가 트랜스파일된 경우에 중요할 수 있습니다.These properties can be important when your JavaScript is transpiled.

scriptFile 사용Using scriptFile

기본적으로 JavaScript 함수는 해당하는 function.json과 동일한 부모 디렉터리를 공유하는 index.js 파일에서 실행됩니다.By default, a JavaScript function is executed from index.js, a file that shares the same parent directory as its corresponding function.json.

scriptFile은 다음 예제와 같은 폴더 구조를 가져오는 데 사용할 수 있습니다.scriptFile can be used to get a folder structure that looks like the following example:

FunctionApp
 | - host.json
 | - myNodeFunction
 | | - function.json
 | - lib
 | | - nodeFunction.js
 | - node_modules
 | | - ... packages ...
 | - package.json

myNodeFunctionfunction.json에는 실행할 내보낸 함수가 있는 파일을 가리키는 scriptFile 속성이 포함되어야 합니다.The function.json for myNodeFunction should include a scriptFile property pointing to the file with the exported function to run.

{
  "scriptFile": "../lib/nodeFunction.js",
  "bindings": [
    ...
  ]
}

entryPoint 사용Using entryPoint

scriptFile(또는 index.js)에서 함수를 찾아서 실행하려면 module.exports를 사용하여 함수를 내보내야 합니다.In scriptFile (or index.js), a function must be exported using module.exports in order to be found and run. 기본적으로 트리거되면 실행되는 함수는 해당 파일의 내보내기, run이라는 이름의 내보내기 또는 index라고 명명된 내보내기입니다.By default, the function that executes when triggered is the only export from that file, the export named run, or the export named index.

다음 예제와 같이 function.json에서 entryPoint를 사용하여 구성할 수 있습니다.This can be configured using entryPoint in function.json, as in the following example:

{
  "entryPoint": "logFoo",
  "bindings": [
    ...
  ]
}

사용자 함수에서 this 매개 변수를 지원하는 Functions v2.x에서 함수 코드는 다음 예제와 같을 수 있습니다.In Functions v2.x, which supports the this parameter in user functions, the function code could then be as in the following example:

class MyObj {
    constructor() {
        this.foo = 1;
    };

    function logFoo(context) { 
        context.log("Foo is " + this.foo); 
        context.done(); 
    }
}

const myObj = new MyObj();
module.exports = myObj;

이 예제에서는 해당 것에 유의 해야 개체를 내보낸 있지만 실행 간에 상태를 유지 하는 것에 대 한 보장 되지 않습니다.In this example, it is important to note that although an object is being exported, there are no guarantees for preserving state between executions.

로컬 디버깅Local Debugging

시작 하는 경우는 --inspect 매개 변수를 지정된 된 포트에서 디버깅 클라이언트에 대 한 Node.js 프로세스를 수신 대기 합니다.When started with the --inspect parameter, a Node.js process listens for a debugging client on the specified port. Azure Functions에서 2.x의 경우 환경 변수 또는 앱 설정을 추가 하 여 코드를 실행 하는 Node.js 프로세스에 전달할 인수를 지정할 수 있습니다 languageWorkers:node:arguments = <args>합니다.In Azure Functions 2.x, you can specify arguments to pass into the Node.js process that runs your code by adding the environment variable or App Setting languageWorkers:node:arguments = <args>.

로컬로 디버그 하려면 추가 "languageWorkers:node:arguments": "--inspect=5858" 아래에서 Values 에서 프로그램 local.settings.json 파일과 5858 포트로 디버거를 연결 합니다.To debug locally, add "languageWorkers:node:arguments": "--inspect=5858" under Values in your local.settings.json file and attach a debugger to port 5858.

VS Code를 사용 하 여 디버깅 하는 경우는 --inspect 매개 변수를 사용 하 여 자동으로 추가 됩니다는 port 프로젝트의 launch.json 파일의 값입니다.When debugging using VS Code, the --inspect parameter is automatically added using the port value in the project's launch.json file.

버전에서 1.x에서 설정 languageWorkers:node:arguments 작동 하지 것입니다.In version 1.x, setting languageWorkers:node:arguments will not work. 디버그 포트를 사용 하 여 선택할 수 있습니다 합니다 --nodeDebugPort Azure Functions 핵심 도구에 대 한 매개 변수입니다.The debug port can be selected with the --nodeDebugPort parameter on Azure Functions Core Tools.

TypeScriptTypeScript

버전 대상 지정의 Functions 런타임 2.x 둘 다 Visual Studio Code에 대 한 Azure Functions 하며 Azure Functions 핵심 도구 지원 템플릿을 사용 하 여 함수 앱을 만들 수 있습니다 TypeScript 함수 앱 프로젝트입니다.When you target version 2.x of the Functions runtime, both Azure Functions for Visual Studio Code and the Azure Functions Core Tools let you create function apps using a template that support TypeScript function app projects. 서식 파일 생성 package.jsontsconfig.json 트랜스 파일을 쉽게 하는 프로젝트 파일을 실행 하 고 이러한 도구를 사용 하 여 TypeScript 코드에서 JavaScript 함수를 게시 합니다.The template generates package.json and tsconfig.json project files that make it easier to transpile, run, and publish JavaScript functions from TypeScript code with these tools.

생성 된 .funcignore 파일 프로젝트를 Azure에 게시 되 면 파일 제외 됩니다 나타내는 데 사용 됩니다.A generated .funcignore file is used to indicate which files are excluded when a project is published to Azure.

TypeScript 파일 (.ts)은 트랜스 파일 된 JavaScript (.js) 파일에는 dist 출력 디렉터리입니다.TypeScript files (.ts) are transpiled into JavaScript files (.js) in the dist output directory. TypeScript 템플릿을 사용 합니다 scriptFile 매개 변수 에서 function.json 해당.js 파일의 위치를 나타내는 dist 폴더.TypeScript templates use the scriptFile parameter in function.json to indicate the location of the corresponding .js file in the dist folder. 출력 위치를 사용 하 여 템플릿에 의해 설정 됩니다 outDir 의 매개 변수는 tsconfig.json 파일입니다.The output location is set by the template by using outDir parameter in the tsconfig.json file. 이 설정을 사용 하거나 폴더의 이름을 변경 하면 런타임이 실행 하는 코드를 찾을 수 없는 경우.If you change this setting or the name of the folder, the runtime is not able to find the code to run.

참고

TypeScript에 대 한 실험적 지원 있는 버전의 Functions 런타임 1.x 합니다.Experimental support for TypeScript exists version 1.x of the Functions runtime. 실험 버전 transpiles 함수를 호출 하는 경우 JavaScript 파일로 TypeScript 파일입니다.The experimental version transpiles TypeScript files into JavaScript files when the function is invoked. 버전에서 2.x의 경우이 실험적 지원을 호스트 초기화 되기 전에 소스 간 컴파일을 수행 하는 도구 기반 메서드 및 배포 프로세스 중 대체 되었습니다.In version 2.x, this experimental support has been superseded by the tool-driven method that does transpilation before the host is initialized and during the deployment process.

로컬로 개발 하 고 TypeScript 프로젝트에서 배포 하는 방식을 개발 도구에 따라 달라 집니다.The way that you locally develop and deploy from a TypeScript project depends on your development tool.

Visual Studio CodeVisual Studio Code

합니다 Visual Studio Code에 대 한 Azure Functions 확장을 사용 하면 TypeScript를 사용 하 여 함수를 개발할 수 있습니다.The Azure Functions for Visual Studio Code extension lets you develop your functions using TypeScript. 핵심 도구는 Azure Functions 확장의 요구 사항입니다.The Core Tools is a requirement of the Azure Functions extension.

Visual Studio Code에는 TypeScript 함수 앱을 만들려면 선택 하기만 하면 TypeScript 을 함수 앱을 만들고 언어를 선택 하 라는 메시지가 표시 됩니다.To create a TypeScript function app in Visual Studio Code, you simply choose TypeScript when you create a function app and are asked to choose the language.

누르면 F5 앱을 실행 하려면 로컬에서 소스 간 컴파일을 수행 됩니다 (func.exe) 호스트 초기화 되기 전에 합니다.When you press F5 to run the app locally, transpilation is done before the host (func.exe) is initialized.

사용 하 여 Azure 함수 앱을 배포할 때의 함수 앱에 배포 하는 중... 단추, Azure Functions 확장 TypeScript 소스 파일에서 먼저 JavaScript 파일의 프로덕션 준비 빌드를 생성 합니다.When you deploy your function app to Azure using the Deploy to function app... button, the Azure Functions extension first generates a production-ready build of JavaScript files from the TypeScript source files.

Azure Functions 핵심 도구Azure Functions Core Tools

핵심 도구를 사용 하는 TypeScript 함수 앱 프로젝트를 만들려면 함수 앱을 만들 때 typescript 언어 옵션을 지정 해야 합니다.To create a TypeScript function app project using Core Tools, you must specify the typescript language option when you create your function app. 다음 방법 중 하나에서이 수행할 수 있습니다.You can do this in one of the following ways:

  • 실행 합니다 func init 명령을 선택 node 언어 스택 및 선택 typescript합니다.Run the func init command, select node as your language stack, and then select typescript.

  • func init --worker-runtime typescript 명령을 실행합니다.Run the func init --worker-runtime typescript command.

핵심 도구를 사용 하 여 로컬로 함수 앱 코드를 실행 하려면 사용 합니다 npm start 대신 명령을 func host start합니다.To run your function app code locally using Core Tools, use the npm start command, instead of func host start. npm start 명령은 다음 명령과 같습니다.The npm start command is equivalent to the following commands:

  • npm run build
  • func extensions install
  • tsc
  • func start

사용 하기 전에 합니다 func azure functionapp publish Azure에 배포 하는 명령, 먼저 실행 해야 합니다는 npm run build:production 명령입니다.Before you use the func azure functionapp publish command to deploy to Azure, you must first run the npm run build:production command. 이 명령을 사용 하 여 배포할 수 있는 TypeScript 소스 파일에서 JavaScript 파일의 프로덕션 준비 빌드를 만듭니다 func azure functionapp publish 합니다.This command creates a production-ready build of JavaScript files from the TypeScript source files that can be deployed using func azure functionapp publish.

JavaScript 함수에 대한 고려 사항Considerations for JavaScript functions

JavaScript 함수로 작업하는 경우 다음 섹션의 고려 사항에 유의해야 합니다.When you work with JavaScript functions, be aware of the considerations in the following sections.

단일 vCPU App Service 계획 선택Choose single-vCPU App Service plans

App Service 계획을 사용하는 함수 앱을 만들 때 여러 vCPU가 있는 계획보다는 단일 vCPU 계획을 선택하는 것이 좋습니다.When you create a function app that uses the App Service plan, we recommend that you select a single-vCPU plan rather than a plan with multiple vCPUs. 현재 Functions는 단일 vCPU VM에서 JavaScript 함수를 더 효율적으로 실행합니다. 더 큰 VM을 사용해도 예상된 성능 향상을 보여 주지 않습니다.Today, Functions runs JavaScript functions more efficiently on single-vCPU VMs, and using larger VMs does not produce the expected performance improvements. 필요한 경우 더 많은 단일 vCPU VM 인스턴스를 추가 하 여 수동으로 확장 수 또는 자동 크기 조정을 설정할 수 있습니다.When necessary, you can manually scale out by adding more single-vCPU VM instances, or you can enable autoscale. 자세한 내용은 수동 또는 자동으로 인스턴스 개수 조정을 참조하세요.For more information, see Scale instance count manually or automatically.

콜드 부팅Cold Start

서버리스 호스팅 모델에서 Azure Functions를 개발하는 경우 콜드 부팅이 현실입니다.When developing Azure Functions in the serverless hosting model, cold starts are a reality. 콜드 부팅이란 일정 기간 동안 비활성이었다가 처음으로 함수 앱을 시작하면 시작하는 데 더 오래 걸린다는 사실을 의미합니다.Cold start refers to the fact that when your function app starts for the first time after a period of inactivity, it takes longer to start up. 특히 종속성 트리가 큰 JavaScript 함수의 경우 콜드 부팅은 중요할 수 있습니다.For JavaScript functions with large dependency trees in particular, cold start can be significant. 콜드 부팅 프로세스의 속도를 높이려면 가능한 경우 함수를 패키지 파일로 실행합니다.To speed up the cold start process, run your functions as a package file when possible. 여러 배포 방법은 기본적으로 패키지 모델에서 실행을 사용하지만 대규모 콜드 부팅이 발생하고 이러한 방식으로 실행하지 않는 경우 이 변경 내용으로 인해 크게 개선될 수 있습니다.Many deployment methods use the run from package model by default, but if you're experiencing large cold starts and are not running this way, this change can offer a significant improvement.

연결 제한Connection Limits

Azure Functions 응용 프로그램에서 서비스별 클라이언트를 사용 하는 경우 모든 함수 호출을 사용 하 여 새 클라이언트를 만들지 마세요.When you use a service-specific client in an Azure Functions application, don't create a new client with every function invocation. 대신, 전역 범위에서 정적 클라이언트를 만듭니다.Instead, create a single, static client in the global scope. 자세한 내용은 Azure Functions에서 연결 관리합니다.For more information, see managing connections in Azure Functions.

다음 단계Next steps

자세한 내용은 다음 리소스를 참조하세요.For more information, see the following resources: