How to Use Netlify Serverless Functions

Netlify Serverless Functions allow you to run server-side code in response to HTTP requests on the Netlify hosting platform. This feature is useful for building dynamic and interactive web applications with functions that can be triggered by client-side JavaScript, APIs, or other HTTP requests. Here's a step-by-step guide on how to use Netlify Serverless Functions:

Set up the project

1. Create a New project and initialize an npm package

mkdir myproject
npn init

2. Install netlify-lambda

npm i netlify-lambda@2.0.9

3. Add required build commands to package.json.

 "scripts": {
    "lambda-serve": "netlify-lambda serve functions",
    "lambda-build": "netlify-lambda build functions"
  },

4. Create a functions folder in root, Inside the functions directory, create a JavaScript file for your lambda function. For example, create a file named myFunction.js.

Note: If you want to run lambda function in local environment then Create also a lambda folder in root, Inside the lambda directory, create a same JavaScript file which are using in functions folder.

Check My Github Repo - https://github.com/manpreets99/netlify-lambda

exports.handler = async function () {
  return {
    statusCode: 200,
    body: 'Hello world!',
  };
};

5. Create netlify.toml file in root.

[build]
  functions = "lambda"

6. Test your Lambda function

Run Locally

npm run lambda-serve

Lambda server is listening on 9000:

http://127.0.0.1:9000/myFunction

Ouput:

Hello world!

Setup on Production

Create a new repo, and push it to your Github.

git init
git add .
git commit -m "First commit"
git remote add origin YOUR_GIT_REPO_URL
git push -u origin main

then deploy on Netlify.

Once your site is deployed, you can test your Lambda function by making a request to its endpoint. The URL will be in the format

https://yoursite.netlify.app/.netlify/functions/function-name

Example:

https://mellow-travesseiro-82d22b.netlify.app/.netlify/functions/myFunction

Result:

Here's an example of using Netlify lambda function in a web page using JavaScript:

Note: if you want to run in locally

fetch('http://127.0.0.1:9000/myFunction')
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error(error))

OR (Production)

fetch('/.netlify/functions/myFunction')
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error(error));

This code fetches the response from your Lambda function and logs it to the console.

Conclusion

Using Netlify serverless functions can be a powerful way to extend the functionality of your static website or web application. These functions allow you to run server-side code without the need for traditional server infrastructure. Here are some conclusions and key takeaways after using Netlify serverless functions:

1. Scalability: Netlify serverless functions automatically scale to handle traffic. You don't have to worry about provisioning or managing servers, making it suitable for applications with varying traffic patterns.
2. Cost-Efficiency: You only pay for the resources you use, which can be cost-effective, especially for small to medium-scale projects.
3. Simplicity: Netlify makes it easy to create and deploy serverless functions. You can write your functions in JavaScript or TypeScript, and they integrate seamlessly with your site.
4. Security: Netlify offers security features like identity and access management (IAM) that can help secure your serverless functions. You can also secure them using authentication and authorization techniques.
5. Speed: Serverless functions can improve the speed of your website by offloading certain tasks to a serverless architecture, reducing the load on your frontend.
6. Third-Party Integrations: You can use serverless functions to integrate with third-party services or APIs. This is useful for tasks like sending emails, processing payments, or fetching data from external sources.
7. Data Processing: Serverless functions are great for processing and transforming data on the server side. This can be especially useful when working with forms, databases, and file uploads.
8. Testing and Debugging: Netlify provides tools for testing and debugging serverless functions. You can use local development environments to test your functions before deploying them to production.
9. Continuous Integration/Continuous Deployment (CI/CD): Netlify can automate the deployment process, making it easy to update your functions and site as your code changes. This helps maintain the reliability and consistency of your application.
10. Use Cases: Serverless functions can be used for various use cases, including contact forms, user authentication, server-side rendering (SSR), and dynamic content generation.
11. Limitations: Serverless functions have certain limitations, such as execution time limits and cold start times. Understanding these limitations is important when designing your application.

Happy Coding! ❤️