Managing external libraries in AWS lambda functions
Tags: aws, lambda, serverless, microservices
Published: 2021-07-03 18:01:17

---
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ljvoug5rwvwne5h7d11u.PNG
---

The popularity of microservices is increasing everyday. The main reason behind this is that we do not need to take care of the server related configurations. Just write down your code and see the magic. Definitely [aws lambda](https://aws.amazon.com/lambda/) is one of the best microservices to perform varieties of tasks.

When we write a lambda function, it is quite obvious that we may need third party modules and those will not be present in that environment. So we need to add them to lambda. Now the question comes **how we can manage them properly?** The best answer would be **using lambda layers**. According to aws document:
>A Lambda layer is a .zip file archive that can contain additional code or data. A layer can contain libraries, a custom runtime, data, or configuration files.

So the idea is that we can create a lambda layer and keep other third party libraries in a zipped file. We can create multiple layers as per our requirements and use the same layer to multiple lambda functions. Let us create lambda layers in both node & python runtime & use it in respective lambda functions.

#### Lambda layer using node
In order to add a node lambda layer we will have to keep the installed dependencies and files in a folder named `nodejs`. Here the folder name has to be `nodejs` so that aws lambda can identify the dependencies. Let us now build a layer which contains the `node-fetch` module that creates http requests with node js. 
1. Create a folder named `nodejs`.
2. Go inside that folder.
3. Open the path in terminal.
4. Create a `package.json` file using `npm init -y`.
5. Then install required dependencies. Here only `node-fetch` will be installed using `npm i node-fetch`.
6. Inside the `nodejs` folder there will be one folder named `node_modules` and two files named `package.json` & `package-lock.json`. Compress the `nodejs` folder to a zipped file.

Now we are ready to create our lambda layer. Just go to the aws console **Create layer** section like the following screenshot. Name your layer, choose a runtime like `Node.js 14.x` & upload the zipped file created. Thus our lambda layer will be created.  
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7jh1e4u4k5ymynix4fo9.PNG)

Now we will use this layer in our lambda function. Assuming that you know how to create a lambda function ( if you don't, no worries coz its quite simple), just add the layer you created to your lambda function. In our lambda function we will make a `GET` request to an api & show the response in a `json` format. Our lambda function code is:
```
const fetch = require("node-fetch");

exports.handler = async (event) => {
    try {
        const response = await fetch(event.url);
        const json = response.json();
        return json;
    } catch(e) {
        return e;
    }
};
```
We will create a test event containing:
```
{
  "url": "https://reqres.in/api/users"
}
```
Now if we hit the `Test` button we should see a response like following:
```
{
  "page": 1,
  "per_page": 6,
  "total": 12,
  "total_pages": 2,
  "data": [
    {
      "id": 1,
      "email": "george.bluth@reqres.in",
      "first_name": "George",
      "last_name": "Bluth",
      "avatar": "https://reqres.in/img/faces/1-image.jpg"
    },
    {
      "id": 2,
      "email": "janet.weaver@reqres.in",
      "first_name": "Janet",
      "last_name": "Weaver",
      "avatar": "https://reqres.in/img/faces/2-image.jpg"
    },
    {
      "id": 3,
      "email": "emma.wong@reqres.in",
      "first_name": "Emma",
      "last_name": "Wong",
      "avatar": "https://reqres.in/img/faces/3-image.jpg"
    },
    {
      "id": 4,
      "email": "eve.holt@reqres.in",
      "first_name": "Eve",
      "last_name": "Holt",
      "avatar": "https://reqres.in/img/faces/4-image.jpg"
    },
    {
      "id": 5,
      "email": "charles.morris@reqres.in",
      "first_name": "Charles",
      "last_name": "Morris",
      "avatar": "https://reqres.in/img/faces/5-image.jpg"
    },
    {
      "id": 6,
      "email": "tracey.ramos@reqres.in",
      "first_name": "Tracey",
      "last_name": "Ramos",
      "avatar": "https://reqres.in/img/faces/6-image.jpg"
    }
  ],
  "support": {
    "url": "https://reqres.in/#support-heading",
    "text": "To keep ReqRes free, contributions towards server costs are appreciated!"
  }
}
```

#### Lambda layer using python
Now we will create a lambda layer to perform the similar functionality in python. We will be installing necessary modules for `requests` to make http request and fetch data from remote api. Now we have to do as following:
1. Create directories like this `build/python/lib/python3.8/site-packages`. We must not make any spelling mistake otherwise we will encounter error while running the lambda. Another important thing is the version of python. You must use the same version of python everywhere. Here I am using 3.8 so while selecting runtime I must select Python 3.8 to avoid errors.
2. Now go inside the `site-packages` folder and install `requests` using pip like this where `-t .` means install everything inside this folder.
3. Now come back to the `build` folder & compress the `python` folder to a zipped file.
4. Now create a lambda layer like previous way & upload the zipped file. Select `Python 3.8` as runtime.
```
mkdir build/python/lib/python3.8/site-packages
cd build/python/lib/python3.8/site-packages
pip install requests -t .
```
Now its time to write down the lambda function. After creating the lambda, code will be as following:
```
import json
import requests

def lambda_handler(event, context):
    response = requests.get(event['url'])
    data = response.json()
    return data
```
Our test event will be same as before & after running the lambda we will get similar json response as output.