MongoDB Academy · 강의

JavaScript로 Atlas Functions 작성하기

학습자는 context 객체를 사용해 연결된 서비스, 환경 변수, 기본 제공 MongoDB 클라이언트에 액세스하는 Atlas Functions를 작성합니다.

JavaScript로 Atlas Functions 작성하기은(는) CoddyKit의 무료 MongoDB Academy 강의입니다. 이것은 4개 중 3번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 MongoDB Academy 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. MongoDB Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

What Are Atlas Functions?

Atlas Functions are server-side JavaScript functions that run in the Atlas App Services managed runtime. They are the execution unit behind database triggers, scheduled triggers, and HTTPS endpoints. Functions have full access to the MongoDB client, environment variables, linked third-party services (HTTP, AWS, Twilio, etc.), and can call other Atlas Functions.

Function Anatomy: exports and context

Every Atlas Function exports a single async function as its entry point via exports = async function(...args) {}. Inside the function, the global context object provides access to Atlas services. The function receives arguments that vary by invocation type: database triggers receive a change event, HTTPS endpoints receive an HTTP request, and called functions receive the arguments passed by the caller.

// Minimal Atlas Function structure
exports = async function(arg1, arg2) {
  // context is globally available
  const db = context.services.get('mongodb-atlas').db('mydb')
  const result = await db.collection('users').findOne({ _id: arg1 })
  return result
}

Accessing MongoDB With context.services

context.services.get('mongodb-atlas') returns a MongoDB client bound to your linked Atlas cluster. From it you get a database handle and then a collection handle — the same API as the Node.js MongoDB driver. Operations are async and should be awaited. The client is pre-configured with the App Services internal credentials, so you do not manage connection strings in function code.

exports = async function() {
  // Get the linked MongoDB service
  const mongodb = context.services.get('mongodb-atlas')
  const db = mongodb.db('mydb')
  const orders = db.collection('orders')

  // Full CRUD API available
  const pending = await orders.find({ status: 'pending' }).toArray()
  await orders.updateMany({ status: 'pending' }, { $set: { notified: true } })

  return { processed: pending.length }
}

Environment Variables: context.values and context.environment

Hardcoding secrets (API keys, passwords) in function code is dangerous. Atlas Functions support two mechanisms for secure config: Values — static strings or secrets stored in App Services and accessed via context.values.get('myValue'). Environment variables — per-environment overrides accessed via context.environment.values.MY_VAR. Use these to store API keys, webhook secrets, and environment-specific settings.

exports = async function() {
  // Retrieve a stored secret (never exposed in function logs)
  const apiKey = context.values.get('STRIPE_SECRET_KEY')

  // Or use environment-specific values
  const webhookUrl = context.environment.values.SLACK_WEBHOOK_URL

  // Use in an HTTP call
  const http = context.services.get('myHTTP')
  await http.post({
    url: webhookUrl,
    headers: { 'Content-Type': ['application/json'] },
    body: JSON.stringify({ text: 'Job complete' })
  })
}

Making HTTP Requests

Atlas Functions can call external REST APIs using a linked HTTP service or the built-in context.http shortcut. This enables integrations with Stripe, SendGrid, Slack, Twilio, GitHub, and any other REST API without deploying additional infrastructure. Always store API keys in Values or Secrets, never in code.

exports = async function(orderId, amount) {
  // Create a Stripe payment intent via REST API
  const stripeKey = context.values.get('STRIPE_SECRET_KEY')
  const response = await context.http.post({
    url: 'https://api.stripe.com/v1/payment_intents',
    headers: {
      'Authorization': ['Bearer ' + stripeKey],
      'Content-Type': ['application/x-www-form-urlencoded']
    },
    body: 'amount=' + Math.round(amount * 100) + '&currency=usd&metadata[orderId]=' + orderId
  })

  const body = EJSON.parse(response.body.text())
  return body.client_secret
}

Calling Other Atlas Functions

Atlas Functions can call each other with context.functions.execute('functionName', arg1, arg2). This promotes reuse — you can write utility functions (send an email, log an event, validate a JWT) once and call them from any trigger or endpoint function. Recursive calls are supported but Atlas limits call depth to prevent infinite recursion.

// Main function calls a utility function
exports = async function(userId) {
  const db = context.services.get('mongodb-atlas').db('mydb')
  const user = await db.collection('users').findOne({ _id: userId })

  // Call a reusable 'sendWelcomeEmail' function
  await context.functions.execute('sendWelcomeEmail', user.email, user.name)

  return { status: 'welcome email sent' }
}

User Context: Who Is Calling?

In functions called by authenticated users (via HTTPS endpoints with user authentication), context.user provides the caller's identity: their user ID, email, roles, and custom data. This lets you build secure, user-scoped logic without passing user IDs manually. Functions invoked by triggers or scheduled jobs have a system-level user context.

// HTTPS endpoint function that is user-scoped
exports = async function({ query, body }) {
  // context.user is populated when the endpoint uses user auth
  const currentUserId = context.user.id
  const db = context.services.get('mongodb-atlas').db('mydb')

  // Users can only read their own data
  const orders = await db.collection('orders')
    .find({ ownerId: currentUserId })
    .toArray()

  return { orders }
}

Error Handling Best Practices

Wrap your function body in try/catch and always re-throw errors after logging them. This ensures Atlas marks the invocation as failed (enabling retry logic for triggers) and the error appears in the execution log with full context. Use structured logging (JSON strings) rather than plain text so logs are machine-parseable.

exports = async function(payload) {
  const start = Date.now()
  try {
    const result = await processPayload(payload)
    console.log(JSON.stringify({ status: 'ok', result, ms: Date.now() - start }))
    return result
  } catch (err) {
    console.error(JSON.stringify({
      status: 'error',
      message: err.message,
      stack: err.stack,
      ms: Date.now() - start
    }))
    throw err  // re-throw so Atlas marks this invocation as FAILED
  }
}

Function Execution Limits

Atlas Functions have important execution limits: Maximum runtime: 90 seconds per invocation. Memory: 256 MB. Code size: 64 KB per function. Response size: 4 MB for HTTPS endpoints. For long-running or memory-intensive operations, design your functions to process data in small batches and use multiple invocations (via scheduled triggers) to handle large datasets.

Testing Functions Locally With app-services-cli

You can develop and test Atlas Functions locally using the Atlas App Services CLI (app-services-cli). Push your function code, trigger configurations, and environment values to App Services with a single command. The CLI also supports pulling your existing configuration as code so you can version-control it in Git alongside your application code.

// Install the App Services CLI
// npm install -g atlas-app-services-cli

// Pull existing config
// appservices pull --remote=<app_id>

// Push updated functions
// appservices push --include-node-modules

// Run a function locally (using App Services CLI)
// appservices function run --name=myFunction --arg='{"key":"val"}'

Function Naming and Organisation

As your App Services application grows, organise functions with consistent naming conventions. Use prefixes or folders: trigger_onOrderInsert, util_sendEmail, api_getProducts. Keep functions small and focused — a function that does one thing is easier to test, debug, and reuse. Extract shared logic into utility functions and call them with context.functions.execute() from multiple callers.

// Organised function naming examples:
// trigger_onOrderInsert  — database trigger handler
// trigger_dailyArchive   — scheduled trigger
// api_getOrders          — HTTPS endpoint handler
// util_sendEmail         — shared email utility
// util_validatePayload   — shared validation utility

// Calling a utility from any other function:
await context.functions.execute('util_sendEmail', {
  to: user.email,
  subject: 'Your order is confirmed',
  body: 'Order ID: ' + orderId
})

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: Atlas Functions export a single async function entry point and access MongoDB, HTTP services, and environment config through the global context object, functions can call each other with context.functions.execute() for reusable utility logic, and always re-throw errors after logging so Atlas marks invocations as failed and retries triggers appropriately. Next up we expose Atlas Functions as HTTPS endpoints.

자주 묻는 질문

“JavaScript로 Atlas Functions 작성하기” 강의는 무료인가요?

네 — “JavaScript로 Atlas Functions 작성하기” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 MongoDB Academy 강의 전체를 잠금 해제할 수 있습니다. MongoDB Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

“JavaScript로 Atlas Functions 작성하기”에서 뭘 배우나요?

학습자는 context 객체를 사용해 연결된 서비스, 환경 변수, 기본 제공 MongoDB 클라이언트에 액세스하는 Atlas Functions를 작성합니다. 브라우저에서 직접 실행하는 실습 코드로 MongoDB Academy을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

MongoDB Academy을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 MongoDB Academy은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 3번째 강의입니다.

“JavaScript로 Atlas Functions 작성하기” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 MongoDB Academy 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 MongoDB Academy 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← MongoDB Academy(으)로 돌아가기