Often people use Nest.js and Prisma together when they program a backend application. Then there is the question of how to deploy the application with Docker. This article shows you how.

## Nest.js

[Nest.js](https://nestjs.com) is a framework for building server-side JavaScript and TypeScript applications. It provides an abstraction atop Express.js or Fastify. It has a good architecture and bigger server-side applications can be programmed faster than with pure Express.js or Fastify.
Often, Nest.js applications use an ORM (Object-Relational Mapping) and thus Prisma comes into play.

## Prisma 

Using an ORM in Node and Nest.js application faciliates manipulating and querying data in a SQL database. Due to the mismatch between an object-oriented programming language like TypeScript and the relational data model, a tool like Prisma is very useful.
Prisma has a single source of truth for the data model which is good design. It can easily be used within a Nest.js application.

Once you develop your Nest.js application, you also need to think about deployment. This is where containers with Docker shine.

## Docker

[Docker](https://www.docker.com) is used to automate the deployment of software in lightweight packages called containers. It is nowadays the standard of deploying server-side software in the cloud.

So when you want to deploy your Nest.js application that uses Prisma to a cloud service that supports Docker, you need to write a *Dockerfile*. The Dockerfile specifies the steps of creating a Docker image.

## How to Dockerize

This  is an example Dockerfile for a Nest.js application that uses Prisma:

```Docker
# Use an official Node.js runtime as the base image
# This line specifies the base image for the Docker image. In this case, we're using an official Node.js runtime image with version 18.18 and the # Alpine Linux distribution.
FROM node:18.18-alpine

# This line sets the working directory inside the container to /usr/src/app. This is where we'll copy our application code and where the # application will run.
WORKDIR /usr/src/app

# This line installs the build-base package using the Alpine package manager (apk). This package includes the necessary tools for building   
# native Node.js modules.
RUN apk add build-base

# This line installs Python 3 using the Alpine package manager. Python is required for some Node.js modules that have native dependencies.
RUN apk add python3

# This line installs the node-gyp package globally using npm. node-gyp is a tool for building native Node.js modules.
RUN npm install -g node-gyp

# Copy package.json and package-lock.json to the container
COPY package*.json ./

# Install application dependencies
RUN npm install

# Copy the rest of your application code to the container
COPY . .

# This line sets an environment variable that tells the Prisma ORM to ignore missing engine checksums. This is useful when deploying to certain 
# platforms like Heroku.
ENV PRISMA_ENGINES_CHECKSUM_IGNORE_MISSING=1

# This line generates the Prisma client code based on the schema defined in the application.
RUN npx prisma generate

# Expose the port that your application will run on (Nest.js default is 3000)
EXPOSE 3000

# Define the command to run your application
CMD ["npm", "start"]
```

I included comments at each line of the *Dockerfile*. Please note that because of Prisma, there have been more steps necessary than for a pure Nest.js application. In this *Dockerfile* I used an Alpine Linux Node image because it is smaller in size and more secure than the standard Node image.

The next step is the build the image using Docker. You can do this with the following command:

```bash
docker build -t <image-name> .
```

Then you can start the image and run it as a container. If you use a tool like Docker Desktop, it is simply clicking on the run button. There also exists a command on the command line:

```bash
docker run -p <host-port>:<container-port> <image-name>
```

In our case, the *container-port* is 3000 (EXPOSE 3000 command in the Dockerfile). Finally, you should be able to access your deployed application.

## Conclusion

As you could hopefully see, Nest.js applications are principally not difficult to dockerize. When using the Prisma client, there are a number of additional steps that need to be taken. I hope you learned something new.

## References

- Nest.js: [https://nestjs.com](https://nestjs.com)

- Prisma: [https://www.prisma.io](https://www.prisma.io)

- Docker: [https://www.docker.com](https://www.docker.com)

Cover photo: <a href="https://unsplash.com/de/@lazycreekimages?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Michael Dziedzic</a> on <a href="https://unsplash.com/de/fotos/dreieckiges-rotes-und-blaues-dreieck-W6l35A_rxxU?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Unsplash</a>
  

large_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

medium_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

small_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

thumbnail_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

Often people use Nest.js and Prisma together when they program a backend application. Then there is the question of how to deploy the application with Docker. This article shows you how.

How to Dockerize a Prisma Nest.js Application

When you use [GitLab](https://gitlab.com/) to host your web software development project source code, you can deploy your website to [Cloudflare Pages](https://pages.cloudflare.com/).
Normally, you would use the GitLab CI pipeline to build your website project. So in this article, I show you how to
configure your GitLab CI to deploy to Cloudflare Pages.

## GitLab

GitLab is a partially open source Git-based hosting and DevOps platform with roots in Ukraine. With its headquarters in San Francisco, it offers issue tracking, continuous integration and a deployment pipeline. Since GitLab does not offer advanced cloud features like hosting static sites or serverless functions, you can combine GitLab with third-party offerings, for example from the Cloudflare company.

## Cloudflare Pages

[Cloudflare](https://www.cloudflare.com/) is a cloud hosting company that offers a CDN and other services for website creators. 
Cloudflare Pages is Cloudflare's offering oriented towards frontend developers who want to quickly
deploy their website. You can connect it directly with GitLab, but you need to authorize Cloudflare to access your GitLab repository.
When you do not want to allow Cloudflare access to your Git repository, you can deploy the code directly from your GitLab CI pipeline.

## Configuring the GitLab CI pipeline

Running a CI pipeline is good practice for every web software project. A CI pipeline is a series
of steps that must be performed to deliver a new version of software.

In GitLab there exists the `.gitlab-ci.yml` where you configure your build and deployment steps.
The `.gitlab-ci.yml` file is a [Yaml](https://yaml.org/) file that contains these commands. The commands are executed in the order they are listed.
It includes a definition of
variables that are necessary for the deployment to Cloudflare Pages. These variables are called `$CLOUDFLARE_API_TOKEN` and `$CLOUDFLARE_ACCOUNT_ID`.
They are passed to the [wrangler](https://developers.cloudflare.com/workers/wrangler/) CLI tool from Cloudflare and are needed to enable authentication. The
`wrangler` CLI tool is a command line interface to the Cloudflare API. It is used here to deploy the frontend code to the
Cloudflare Pages server.

In order to protect these access tokens, they need to be defined directly in the GitLab settings under `CI/CD`. There you need
to expand the `Variables` section and add the values. They will subsequently be filled in when the CI pipeline runs.

In the Cloudflare web application, under `My Profile/API Token`, you can generate these API tokens. You need to create a token that has at a minimum the rights to
to edit Cloudflare Pages (`Cloudflare Pages:Edit`) and to read the membership (`Memberships:Read`).

Then you can create the CI deployment script in your GitLab project.

You can use this script as an example:

.gitlab-ci.yml

```yaml
image: node:16.13

cache:
  paths:
    - node_modules/
    - .cache/
    - public/

pages:
  variables:
    CLOUDFLARE_API_TOKEN: $CLOUDFLARE_API_TOKEN
    CLOUDFLARE_ACCOUNT_ID: $CLOUDFLARE_ACCOUNT_ID
  stage: deploy
  script:
    - npm install
    - ./node_modules/.bin/gatsby build
    - npm install -g wrangler --unsafe-perm=true
    - wrangler pages publish ./public --project-name=your-website --branch=main
  artifacts:
    paths:
      - public
  only:
    - master
```

This script statically generates a static JavaScript website using Gatsby and deploys it to Cloudflare Pages using `wrangler`.
For this script to work in your project you need to customize the values passed to `wranger`, especially the `--project-name`. It is the name you chose when creating the Cloudflare Pages project.
Also, you might need to adapt the folder name where the generated frontend code that needs to be deployed is located. In the example above, it is `./public`.

## Conclusion

As I hope you could learn from this article, that integrating a deployment to Cloudflare Pages from the GitLab CI is
not very complicated. A similar approach can be used for other CI build applications.

## References

- GitLab: https://gitlab.com/

- Cloudflare Pages: https://pages.cloudflare.com/

- Cloudflare Wrangler: https://developers.cloudflare.com/workers/wrangler/

large_cover.png

medium_cover.png

small_cover.png

thumbnail_cover.png

When you use GitLab to host your web software development project source code, you can deploy your website to Cloudflare Pages. Normally, you would use the GitLab CI pipeline to build your website project. So in this article, I show you how to configure your GitLab CI to deploy to Cloudflare Pages.

How to Deploy from GitLab to Cloudflare Pages

Netlify Functions are serverless code that are easy to deploy. Here I want
to show how to program a simple Netlify Function to send a contact message from my website
to an email address and log it into an Airtable sheet.
Behind the scenes, Netlify uses AWS Lambda functions and handles all the complex chores
like configuring an API gateway and so on.

## Netlify

[Netlify](https://www.netlify.com/) is a San Francisco based company offering hosting of static sites and serverless functions. It was
founded in 2014 and has a generous amount of free serverless functions.
The company focuses on the Jamstack use-case, which is an evolving movement to use static sites and
serverless code to deliver simpler, faster and more secure websites.

## Sendgrid

The service I use here to send the contact message
to my email address is Sendgrid by Twilio.

[Twilio](https://www.twilio.com/) is a San Francisco based communication web company that offers cloud 
APIs for messaging. You can send a number of emails for
free per month with the free plan.


## Airtable

[Airtable](https://airtable.com/) is also San Francisco based and is a provider of a
communication platform with an API. 
For our purpose, you need to create a base that we use for logging the
contact request from our website. 
You need to add the four fields ("Name", "Email" and "Message" and "Date").
Later, when a user sends a message, the data will be logged in the Airtable
base, and you can view it.

## Preparation

For simple deployment, Netlify offers a command line
based tool called Netlify CLI. You can install it via:

```bash
npm install netlify-cli -g
```

For more information on setting up Netlify CLI and logging
into your account, visit the documentation page: 

https://docs.netlify.com/cli/get-started/

## The package.json

The contact form TypeScript project uses the following
third-party packages:

```json
{
  "name": "contact-form",
  "version": "1.0.0",
  "description": "Netlify function for contact form messaging",
  "main": "contact-form.ts",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "netlify",
    "serverless",
    "typescript"
  ],
  "author": "Netlify",
  "license": "MIT",
  "dependencies": {
    "@netlify/functions": "^0.7.2",
    "@sendgrid/mail": "^7.4.7",
    "airtable": "^0.11.1",
    "typescript": "^4.0.0"
  },
  "devDependencies": {
    "@types/node": "^16.9.6"
  }
}
```

The two packages for the integration of Sendgrid and
Airtable are included in this file.

## The Contact Function

The contact function is written in TypeScript and looks
like this:

```typescript
import { Handler } from "@netlify/functions";
import sendgridMail from "@sendgrid/mail";
import Airtable from 'airtable';

sendgridMail.setApiKey(process.env.SENDGRID_API_KEY);

Airtable.configure({ apiKey: process.env.AIRTABLE_API_KEY })
const base = Airtable.base('app1x2RVWTmxkxcxx');

export const handler: Handler = async (event) => {
  const { email, name, message } = event.queryStringParameters;
  const date = new Date();

  base('Table 1').create([
    {
      "fields": {
        Name: name,
        Email: email,
        Message: message,
        Date: `${date.getMonth()+1}/${date.getDate()}/${date.getFullYear()}`,
      }
    },
  ], (err) => {
    if (err) {
      console.error(err);
    } else {
      console.log("Successfully logged to Airtable!");
    }
  });

  const msg = {
    to: "youraddress@mail.com",
    from: "youremail@website.com",
    subject: "Contact Message from Website",
    text: `Message from ${name} with email ${email}: ${message}`,
    html: `Message from ${name} with email ${email}: ${message}`,
  };

  try {
    await sendgridMail.send(msg);
  } catch (error) {
    console.error(error);

    if (error.response) {
      console.error(error.response.body);

      return {
        statusCode: 400,
        headers: {
          'Access-Control-Allow-Origin': '*', // Required for CORS support to work
        },
        body: JSON.stringify({
          message: 'Error: '+JSON.stringify(error.response.body)
        }),
      };
    }
  }

  return {
    statusCode: 200,
    headers: {
      'Access-Control-Allow-Origin': '*', // Required for CORS support to work
    },
    body: JSON.stringify({
      message: 'Success!'
    }),
  };
};
```

Before you can run the function locally, you need to set the
environmental variables. In Linux-based systems, you can simply
run ```export SENDGRID_API_KEY=your-key``` in the terminal.
The same with the variable ```AIRTABLE_API_KEY```.

Furthermore, you need to adapt the Airtable variable in the code
with your own ID, as well as adapt the table name ("Table 1") if
it is different.

Also, in order to receive the email message, you should enter your
email address in the '''msg.to''' property.

## Testing the Function

You can run and test the function locally with 
the following command:

```
netlify dev
```

You can test the GET http function in your
web browser or using a tool like [Insomnia](https://insomnia.rest/) by going
to:

```
http://localhost:8888/.netlify/functions/contact-form/?name=Wolf&email=test@wolf.com&message=Hi!
```

If it was successful, you should receive an email and the parameters should
be logged in your Airtable base.

## Deploying to Production

Now if everything worked fine you can deploy your function
to production with one simple command:

```
netlify deploy --prod
```

You also get a secure https endpoint after the deployment. This
secure endpoint you can use in your frontend code to call
the function.

Be aware that you need to set your environmental variables in the
Netlify web application where you configured and set up your function.


## Conclusion

Netlify Functions are an easy way to program and deploy
AWS lambda functions. They integrate well with third party APIs
and using the CLI tool you can test it easily locally, thus
speeding up development.

## References

- Netlify Functions: https://docs.netlify.com/functions/overview/

- Twilio Sendgrid: https://www.twilio.com/sendgrid

- Airtable: https://airtable.com

- Insomnia API client: https://insomnia.rest/

large_cover.jpg

medium_cover.jpg

small_cover.jpg

thumbnail_cover.jpg

Netlify Functions are serverless code that are easy to deploy. Here I want to show how to program a simple Netlify Function to send a contact message from my website to an email address and log it into an Airtable sheet.

Easy Netlify Functions for Contact Messaging

[GitLab](https://gitlab.com/) is a popular git-focused DevOps platform. [Netlify](https://netlify.com) is a cloud computing startup that
offers to host your static site.
In this article, I show how to configure the GitLab build pipeline to deploy to a Netlify project.

## GitLab

GitLab is a partially open source git-based hosting and DevOps platform with roots in Ukraine.
With its headquarters in San Francisco, it offers issue tracking, continuous integration and
a deployment pipeline.
Since GitLab does not offer advanced cloud features like hosting static sites or serverless functions,
you can combine GitLab with third-party offerings, for example from the Netlify company.

## Netlify

Netlify, also San Francisco based, offers hosting of static sites and serverless functions. It was
founded in 2014 and has a generous freemium business model.
I use Netlify in this article to host the static files generated by the GitLab build pipeline.

## Deploy to Netlify from GitLab

When using both products and when you do not want to allow Netlify full access to your GitLab account,
you can configure the GitLab build pipeline. In this example, I generate a static site with
the Gatsby Node application and deploy it to Netlify.

The build pipeline configuration file in GitLab looks like this:

.gitlab-ci.yml
```yml
default:
  image: node:14-buster

before_script:
    - npm install
    - npm install -g netlify-cli --unsafe-perm=true
    - npm run build

deploy-job:
  stage: deploy
  script:
    - netlify deploy --site $NETLIFY_SITE_ID --auth $NETLIFY_AUTH_TOKEN --dir public/ --prod
```

The image is a Node image, since my application runs using Node 14.
In the before_script section, I install and build the application. This generates
the static website. I also install [netlify-cli](https://www.npmjs.com/package/netlify-cli) since using that application
I can easily deploy to Netlify. The option unsafe-perm suppresses the UID/GID switching
when running package scripts and is necessary to get permission to run the netlify executable.

In the deploy-job section of the yaml file, the netlify command deploys the website files
from the public folder into the Netlify site specified by the variable `$NETLIFY_SITE_ID`.
You can configure this variable and the Netlify authentication token in the CI/CD settings
of GitLab.

![GitLab CI/CD variables](./gitlab-variables.png)

Retrieve the value of both variables from the settings of your Netlify project.
The site ID (API ID) is located under "Site details". In order to generate your
authentication token, go to "User settings" and "Applications" and there you can 
generate the personal access token that you add as a variable in GitLab.
Important is that you set your Netlify project as a manual deploy project. 

After you have committed the .gitlab-ci.yml file, your static website gets
automatically deployed to your Netlify site whenever you commit and push
to your project in GitLab.

## Conclusion
For me, configuring the GitLab pipeline to deploy to Netlify was straightforward.
I hope with this article, it will be even easier for you. 

## References

- GitLab: https://gitlab.com/

- Netlify: https://netlify.com

- Netlify-cli: https://www.npmjs.com/package/netlify-cli

- Cover photo: <a href="https://unsplash.com/@pietrozj?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Pietro Jeng</a> on Unsplash.
  

large_net.jpg

medium_net.jpg

small_net.jpg

thumbnail_net.jpg

GitLab is a popular git-focused DevOps platform. Netlify is a cloud computing startup that offers to host your static site. In this article, I show how to configure the GitLab build pipeline to deploy to a Netlify project.

Deploying to Netlify from GitLab

With Gatsby, you can generate a static website that works great with cloud
storage solutions like Google Cloud Storage. How to configure
Gatsby and use Infrastructure as Code tools like Terraform I want to show
in this article.

## Google Cloud Storage

In Google Cloud Storage (GCS) you can store files of any type (binary and text) on Google's
servers. The storage is organized in buckets, which are referenced by globally unique identifiers.
Within each bucket, you can have multiple files and directories. There are
different types of buckets, depending on use case. For example, you can have single region
or multiple region replication, buckets for archival purposes and other needs.

You can manage the buckets via a web interface or using the REST API and a command line application (gsutil).

The following picture is taken from the web interface storage browser where you can manage your buckets.

![Google Cloud Storage browser](./storage-browser.png)

For the creation of the example bucket, we will use a popular tool called Terraform.

## Terraform

Manually configuring cloud services is fine for getting to know them. But when you work
with cloud services on a daily basis, you rather need to find a way to automate your work.
This is the mantra of Infrastructure as Code (IaC). That means you programmatically
create the infrastructure and thus can easily automate tasks. This saves time and
increases reliability. One tool to enable IaC is Terraform.

Behind the scenes, Terraform invokes the REST APIs of the respective services.
That means in most cases you need to set up the environmental variables for the
API keys and install the CLI tools. For GCS, you can follow this tutorial: https://cloud.google.com/sdk/

You also need to install the Terraform application (https://learn.hashicorp.com/terraform/getting-started/install), which is just one file.

Since we want to deploy a static Gatsby website, all files need to be
publicly visible. Thus, there is a public_rule resource defined
that makes the web files publicly readable.

This is the Terraform definition file:

google-bucket.tf

```bash
resource "google_storage_bucket_access_control" "public_rule" {
  bucket = google_storage_bucket.static-site.name
  role   = "READER"
  entity = "allUsers"
}

resource "google_storage_bucket" "static-site" {
  name          = "test-yoursite-com"
  project       = "yoursite"
  location      = "EU"
  force_destroy = true
  storage_class = "STANDARD"

  website {
    main_page_suffix = "index.html"
    not_found_page   = "404.html"
  }
}
```

Replace test-yoursite-com with the unique ID of your
own Gatsby site.

After you run _terraform init_ and _terraform apply_,
the bucket test-yoursite-com will be created on GCS.

You can confirm the successful creation by opening
the storage browser in the Google Cloud Console:

https://console.cloud.google.com/storage

## Gatsby

Gatsby is a static website generator. For these
kinds of websites, no real server is needed. Instead,
cloud storage solutions like Google Cloud Storage are
ideal. The amount of money you pay compared to running
a full server is minimal.

One thing to note when using Gatsby with Google Cloud Storage
is that by default, all websites are hosted by their bucket name
under the https://storage.googleapis.com/ domain.

For example, the test bucket would be hosted under:
https://storage.googleapis.com/test-yoursite-com

For this to work in Gatsby, you need to add one option in the _gatsby-config.js_:

gatsby-config.js

```js
module.exports = {
  pathPrefix: "/test-yoursite-com",
...
```

Then you need to generate your Gatsby site with

```
gatsby build --prefix-paths
```

That ensures that the file paths and links are created correctly.

After that, simply upload the contents of your Gatsby _public_ folder
to the bucket with the Google Cloud CLI command:

```bash
cd public
gsutil cp -r . gs://test-yoursite-com
gsutil iam -r ch allUsers:objectViewer gs://test-yoursite-com
```

The second gsutil command makes all files publicly viewable.

## Conclusion

With Gatsby, you can create static sites that work well with
cloud storage solutions like Google Cloud Storage.
Using Terraform automates the creation of buckets and
makes it reproducible.

## References

- Google Cloud Storage: https://cloud.google.com/storage/

- Terraform: https://www.terraform.io/

- Gatsby: https://www.gatsbyjs.org/


large_shelf.jpg

medium_shelf.jpg

small_shelf.jpg

thumbnail_shelf.jpg

With Gatsby, you can generate a static website that works great with cloud
storage solutions like Google Cloud Storage. How to configure
Gatsby and use Infrastructure as Code tools like Terraform I want to show in this article.

Gatsby with Google Cloud Storage and Terraform

[Serverless](https://serverless.com/) is a framework for building and deploying serverless code. Provisioning and
scaling is automatically handled by the cloud provider. The Serverless framework is an abstraction on
top of the most important cloud providers. This tutorial will show how to write a function that
sends an email with customer contact information to you. This is a popular use case for contact forms on websites.

For the purpose of this tutorial, the [Twilio Sendgrid API](https://github.com/sendgrid/sendgrid-nodejs/tree/master/packages/mail) will be used to send an email.
This tutorial requires some basic knowledge of JavaScript and API calls.

## Serverless Computing

[Serverless computing](https://en.wikipedia.org/wiki/Serverless_computing), also known as function as a service (FaaS) was first pioneered by
Amazon AWS with AWS Lambda in 2014. Despite its name serverless, there are servers involved.
But the developer does not need to care for this server. She can write the server
code and then run a command to automatically deploy the function. Scaling is handled
by the cloud provider. Often, the pricing is based on function call
number and memory or CPU time.

This means fixed server costs that traditionally were
calculated based on how long the server runs are now transformed in variable costs
based on the number of calls and memory or CPU.

The new use cases for serverless computing are for example resizing an image after
upload or sending an email to the service department when the customer enters his contact
information and message on a website contact form.

This tutorial describes the latter use case. Other use cases include event streaming, and more
are listed on the [Serverless website](https://serverless.com/learn/use-cases/).

## Serverless Framework

The [Serverless framework](https://serverless.com/) is a free and open source framework written in Node.js.
It supports all major cloud providers like [AWS](https://aws.amazon.com/), [Google Cloud](https://cloud.google.com/), [Azure](https://azure.microsoft.com/en-us/), [Cloudflare Workers](https://www.cloudflare.com/de-de/products/cloudflare-workers/)
and [Alibaba Cloud](https://us.alibabacloud.com/). There is also an enterprise version that the company behind
the Serverless framework, Serverless Inc. supports.
Serverless Inc. is a startup based in San Francisco, USA and has the backing
of [Trinity Ventures](https://www.trinityventures.com), among others.

The installation of Serverless is pretty straightforward. Just follow
the instructions of the [Serverless docs page](https://serverless.com/framework/docs/getting-started/).

Next, clone the [serverless-message example application](https://github.com/tderflinger/serverless-message) from the GitHub repository.
Run _npm install_ and this resolves the package dependencies.

## Configuration

All major configuration is done in the file _serverless.yml_.
There, you can find information on which cloud provider to use,
which runtime and which region.
Under _functions_ the name of the function is specified,
its http method (POST) and that CORS should be enabled. Also,
this is a private function, meaning the caller needs to include
the API key in the header of the POST call. The value of
the API key is in the _apiKeys value_ section.

serverless.yml

```yml
service: serverless-message

provider:
  name: aws
  runtime: nodejs8.10
  region: eu-central-1
  apiKeys:
    - name: firstKey
      value: JNJSNKMKDMKSMKMDKMDK
  environment:
    SENDGRID_API_KEY: Your API Key
    MESSAGE_TO: Your email address
    MESSAGE_FROM: The sender email address (your website domain)
  usagePlan:
    quota:
      limit: 5000
      offset: 2
      period: MONTH
    throttle:
      burstLimit: 20
      rateLimit: 10

functions:
  sendMessage:
    handler: handler.sendMessage
    events:
      - http:
          path: send-message
          method: post
          cors: true
          private: true

plugins:
  - serverless-offline
```

There are also three variables defined that need to be set by you.
The `SENDGRID_API_KEY` is your Sendgrid API key. It can be created after signing
up to [Twilio Sendgrid](https://www.twilio.com/sendgrid).

The other two environment variables are the email address where the
contact message of the client should be sent to. This is normally
your business email address. There you will receive the message when
a client submits on your website. The `MESSAGE_FROM` variable
is the email address of your website.

The other section is the _usagePlan_ that is a security feature where
you can set the maximum number of monthly invocations.

## Serverless Function

This is the meat of the application. The handler function is just a
normal JavaScript function. You can import code from Node packages.
In this case, the _@sendgrid/mail_ is needed for sending out the email.

Otherwise, the function is simple. It sends an email
with the data (name, email, message) that was included as a body of the POST call.

The frontend will later need to post the data from the information that the customer entered
in a form. Currently, the frontend is not part of this application.

handler.js

```javascript
'use strict'

const sgMail = require('@sendgrid/mail')

function sendEmail(data) {
  sgMail.setApiKey(process.env.SENDGRID_API_KEY)
  const msg = {
    to: process.env.MESSAGE_TO,
    from: process.env.MESSAGE_FROM,
    subject: 'New Message from Website',
    text: `Message from ${data.name} - ${data.email}: ${data.message}`,
    html: `<strong>Message from ${data.name} - ${data.email}: ${data.message}</strong>`,
  }
  sgMail.send(msg)
}

module.exports.sendMessage = (event, context, callback) => {
  const data = JSON.parse(event.body)
  sendEmail(data)

  const response = {
    statusCode: 201,
    headers: {
      'Access-Control-Allow-Origin': '*', // Required for CORS support to work
    },
    body: JSON.stringify({
      message: 'Message sent successfully.',
      input: event,
    }),
  }

  callback(null, response)
}
```

The function return a 201 success code with a success message.

## Testing Offline

The good thing about Serverless is that it has a good plugin ecosystem.
There is also a very useful plugin for testing the AWS serverless function locally on
your PC. This plugin is called [serverless-offline](https://github.com/dherault/serverless-offline).

You can run the function locally with:

```bash
sls offline
```

This starts a local server and also prints the API key. You can for example use [Postman](https://www.getpostman.com/) to
run a POST command against the server. You need to include the API key in the
header (x-api-key).

Here is an example POST message body:

```json
{
  "email": "superman@superduppa8.com",
  "name": "Superman",
  "message": "Greetings to Nietzsche!"
}
```

When you do that, an email with this information will be sent to your configured email address.

## Deploying

Deploying is easy but can take a bit of time since all resources need to be
uploaded and provisioned.

Just run the command:

```bash
sls deploy
```

Please note that you need a functional AWS CLI installed locally, and
the AWS user needs to have the correct rights to install AWS lambda functions.
Refer to the [AWS documentation](https://docs.aws.amazon.com/cli/index.html) and the tutorials on Serverless listed below.

## Conclusion

Serverless greatly simplifies the development of serverless functions.
Also, it enables you to relatively easily switch cloud providers, avoiding
vendor lock-in.
As an open source framework it has a big ecosystem, is popular and
has the backing of a commercial company.

## Sources and Further Reading

- Serverless: https://serverless.com

- Serverless Offline: https://github.com/dherault/serverless-offline

- Twilio Sendgrid: https://www.twilio.com/sendgrid

- Tutorials as introduction to Serverless: https://hackernoon.com/best-tutorials-to-get-started-with-serverless-97c86623cdc0

- serverless-message example application: https://github.com/tderflinger/serverless-message


large_serverless.jpg

medium_serverless.jpg

small_serverless.jpg

thumbnail_serverless.jpg

Serverless is a framework for building and deploying serverless code. Provisioning and scaling is automatically handled by the cloud provider. This tutorial will show how to write a function that sends an email with contact information. This is a popular use case for contact forms on websites.

Serverless for Contact Messaging

[Terraform](https://www.terraform.io/) is an [Infrastructure as Code (IaC)](https://en.wikipedia.org/wiki/Infrastructure_as_code) tool by HashiCorp. Using it, you can reproducibly create
server instances on cloud providers like AWS or Digital Ocean. In this article
I show you how to create an [AWS EC2 Spot](https://aws.amazon.com/ec2/spot/) instance server with Terraform.

AWS EC2 Spot instances are EC2 instances available at discount prices. EC2 (Elastic Compute Cloud) is Amazon's term for
servers in their data center that you can do basically anything you want with. You can use it to run software.
For my purpose, I am using an instance to create a [CentOS](https://www.centos.org/) Linux server for testing purposes. After the testing
is done, the EC2 Spot instance is destroyed.

First, you need to sign up to AWS and [install the AWS command line tool (CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html).

Terraform is accessing the AWS CLI and using the credentials you have configured there. After [installing Terraform](https://learn.hashicorp.com/terraform/getting-started/install.html),
we define a Terraform file that contains the configuration. The file has an .tf file name ending.

The creation of an EC2 instance is a little bit more complicated, because you need to define
networking and security rules.

You can find the source code on my GitHub page under: https://github.com/tderflinger/terraform-ec2-spot

## VPC

First, you define your VPC (Virtual Private Cloud) network that is a logically isolated subnetwork
of the AWS cloud.

```
resource "aws_vpc" "test-env" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true
}

resource "aws_subnet" "subnet-uno" {
  # creates a subnet
  cidr_block        = "${cidrsubnet(aws_vpc.test-env.cidr_block, 3, 1)}"
  vpc_id            = "${aws_vpc.test-env.id}"
  availability_zone = "us-east-1a"
}
```

This definition uses the concept of CIDR addresses. The concept of the network
addresses is nicely explained in the [Digital Ocean article](https://www.digitalocean.com/community/tutorials/understanding-ip-addresses-subnets-and-cidr-notation-for-networking).

The availability zone is us-east-1a, but you can choose the one you prefer. You can
look up your availability zone in this [AWS article](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html).

## Security Groups

After that, you need to define your security groups. They are like a firewall. In this
case I allow port 22 (SSH), port 80 (HTTP) and 443 (HTTPS) in. The ingress part
is the data inflow. Egress is the outflow and everything can flow out.

```
resource "aws_security_group" "ingress-ssh-test" {
  name   = "allow-ssh-sg"
  vpc_id = "${aws_vpc.test-env.id}"

  ingress {
    cidr_blocks = [
      "0.0.0.0/0"
    ]

    from_port = 22
    to_port   = 22
    protocol  = "tcp"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_security_group" "ingress-http-test" {
  name   = "allow-http-sg"
  vpc_id = "${aws_vpc.test-env.id}"

  ingress {
    cidr_blocks = [
      "0.0.0.0/0"
    ]

    from_port = 80
    to_port   = 80
    protocol  = "tcp"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_security_group" "ingress-https-test" {
  name   = "allow-https-sg"
  vpc_id = "${aws_vpc.test-env.id}"

  ingress {
    cidr_blocks = [
      "0.0.0.0/0"
    ]

    from_port = 443
    to_port   = 443
    protocol  = "tcp"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}
```

## Internet Gateway

Then you need to define your Elastic IP address, that is the IPv4 IP address where you can reach your server.
You also need to declare a couple of resources, like an [Internet Gateway](https://docs.aws.amazon.com/de_de/vpc/latest/userguide/VPC_Internet_Gateway.html) that serves as a network
address translation (NAT) and routing tables.

```
resource "aws_eip" "ip-test-env" {
  instance = "${aws_spot_instance_request.test_worker.spot_instance_id}"
  vpc      = true
}

resource "aws_internet_gateway" "test-env-gw" {
  vpc_id = "${aws_vpc.test-env.id}"
}

resource "aws_route_table" "route-table-test-env" {
  vpc_id = "${aws_vpc.test-env.id}"

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = "${aws_internet_gateway.test-env-gw.id}"
  }
}

resource "aws_route_table_association" "subnet-association" {
  subnet_id      = "${aws_subnet.subnet-uno.id}"
  route_table_id = "${aws_route_table.route-table-test-env.id}"
}
```

## SSH Access

Next, you will want to securely log in to your server. For that you define
the public key with that you can log in. You need to adapt the
file path to your public key on your system.

```
resource "aws_key_pair" "spot_key" {
  key_name   = "spot_key"
  public_key = "${file("/home/xx/.ssh/id_rsa.pub")}"
}
```

## Spot Request

The last piece in the Terraform definition file is the actual spot
instance request. There, you have to define the [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/de_de/AWSEC2/latest/UserGuide/AMIs.html). The AMI is
basically an image file that contains the operating system.
In our case it is CentOS 7.4. You can find a list of public AMIs of your region in the AWS console under
the EC2 menu.

You also need to define an appropriate instance type.
On the AWS page, you can find a list of [instance types](https://aws.amazon.com/ec2/instance-types/?nc1=h_ls).
The other properties are references to the SSH key, to the
security groups and the subnet ID.
In the _spotprice_ entry, you specify how much the EC2 spot instance should cost maximally per minute.
The _blockdurationminutes_ specifies the time of the duration of the instance.
After that time, the instance is automatically destroyed.

```
resource "aws_spot_instance_request" "test_worker" {
  ami                    = "ami-66a7871c"
  spot_price             = "0.016"
  instance_type          = "t3.small"
  spot_type              = "one-time"
  block_duration_minutes = "120"
  wait_for_fulfillment   = "true"
  key_name               = "spot_key"

  security_groups = ["${aws_security_group.ingress-ssh-test.id}", "${aws_security_group.ingress-http-test.id}",
  "${aws_security_group.ingress-https-test.id}"]
  subnet_id = "${aws_subnet.subnet-uno.id}"
}
```

## Running Terraform

In order to actually apply and create the EC2 spot instance, you need to call Terraform
in the directory where you stored the definition file.

Be aware that your AWS user that you configured in your AWS CLI must have the rights
to create EC2 instances. Use the [AWS IAM](https://aws.amazon.com/iam/?nc1=h_ls) console to create the necessary rights.

Use the following two commands to run the creation of the EC2 spot instance:

```bash
terraform init
terraform apply
```

It will ask you the region and whether everything is good to go.
After the successful creation, there will be a terraform.tfstate file. In it you
can find the public IP address for the instance.
Also, in the AWS web interface, you can go to the EC2 section. There you will find your instance, and you
also can get the public IP address.

You can then connect with SSH to
the public instance like this:

```bash
ssh root@ip
```

When you do not need the instance anymore run the destroy command:

```bash
terraform destroy
```

## Conclusion

A server instance on Amazon EC2 is not as easy to set up as on other providers like
Digital Ocean. But you have more possibilities to configure.
With Terraform, you have the opportunity of an automatic and easily configurable
creation of EC2 Spot instances. The mantra of Infrastructure as Code is to be
able to automate as much as possible all system administration tasks.
Terraform is a vital tool in this respect.

In one of my next articles, I will show you how to use Ansible to provision the
just created EC2 spot instance.

## Sources and Further Reading

- Infrastructure as Code: Managing Servers in the Cloud, 2016, Kief Morris, O'Reilly Media

- Source code of this article: https://github.com/tderflinger/terraform-ec2-spot

- Article by Hasitha Algewatta: https://medium.com/@hmalgewatta/setting-up-an-aws-ec2-instance-with-ssh-access-using-terraform-c336c812322f

- Article by Digital Ocean on networking: https://www.digitalocean.com/community/tutorials/understanding-ip-addresses-subnets-and-cidr-notation-for-networking

- CIDR address calculation tool: https://www.ultratools.com/tools/netMask

- Article by Alberto Acuna: https://blog.albertoacuna.com/using-terraform-to-create-an-ec2-instance-within-a-public-subnet-in-aws/


large_cloud.jpg

medium_cloud.jpg

small_cloud.jpg

thumbnail_cloud.jpg

Terraform is an Infrastructure as Code (IaC) tool by HashiCorp. Using it you can reproducibly create server instances on cloud providers like AWS or Digital Ocean. In this article, I show you how to create an AWS EC2 Spot instance server with Terraform.

Create an EC2 Spot Instance with Terraform

Happy to answer any questions you might have. Or simply say hello!

Thoughts by Thomas Derflinger

Cloud Category