grandeduc - Fotolia


Manage app dependencies carefully for serverless platforms

Application dependencies are tough to manage in serverless computing. Developers need to take specific steps, including the establishment of a well-defined CI/CD process, to cope.

Serverless platforms are, by design, lightweight. This makes the functions that run on them fast and efficient, but they also present a host of new challenges related to application design and deployment, including how you manage dependencies.

According to the second step in the 12-factor methodology for application development, teams should explicitly declare and isolate app dependencies. And while developers generally accomplish this through the use of packaging systems in most modern programming languages, it's not as straightforward with serverless.

Here's a look at why app dependencies can pose a challenge on serverless platforms and how to overcome them.

Native modules

Native node package managers (NPMs) present the first hurdle to app dependency management in a serverless environment. While the majority of NPM packages are simple, JavaScript source files, some require you to install and configure platform-specific binary executables. Because developers compile these packages during dependency installation, they aren't architecture-agnostic. This means developers can't easily deploy them to a serverless environment, unless that environment is directly compatible with the deployment pipeline platform.

This problem becomes increasingly difficult with lower-level languages, such as C. In this instance, every package is a native module, which means developers need to work out a way to use any dependency. Many cloud providers suggest developers compile native modules on a machine that closely resembles the architecture of the serverless environment, or -- even better -- use a package that relies on simple source files rather than platform-specific binaries. Either way, you'll have to jump through a few hoops to solve this particular issue.

Deployment packages

Sometimes, the deployment of serverless functions feels like you're going against the grain. For example, to deploy a function to AWS Lambda, you'll need to create a deployment package.

A deployment package is a zip file that contains the function's code and any of its dependencies. This means that, rather than rely on the dependency manager during a typical atomic deployment process, a serverless deployment package requires you to download and configure all dependencies before delivery to the server.

The fewer dependencies a project has, the better it performs.

For smaller projects with serverless platforms, this shouldn't be too frustrating, but for frequent deployments, this process could be more time-consuming than it's worth. To deal with this more efficiently, establish a well-defined CI/CD process to handle functions with app dependencies. Rather than manually compose the deployment package prior to each release, automate this process, and treat it like any other application development workflow.

Application bundlers

In some instances, the built-in NPM isn't enough to deal with dependencies in a serverless environment. This is where tools like webpack come into play.

Webpack is an application bundler that developers can use to automate just about any process in a typical JavaScript project. There are webpack plug-ins available for each of the major serverless platforms.

Rather than prebundle and upload a zip -- either manually or within a CI/CD pipeline --developers can use these webpack plug-ins to build the code, install dependencies, package the app and deploy it to the serverless platform with minimal overhead. This provides a clean and consistent way to manage dependencies in more complex applications.

Lighten the load

While it's not always possible to reduce the number of required app dependencies, developers should attempt to isolate the necessary dependencies within each function on a serverless platform. This allows each function to be lean and avoids the bloat that can come with monolithic applications. The fewer dependencies a project has, the better it performs.

And the less code you write, the more maintainable your code base is. Not every package is a required dependency, so boil it down to simple and performant code. This will go a long way toward having a maintainable serverless project.

Dig Deeper on Cloud app development and management

Data Center