Overview

Prerequisites are mentioned below

• Kubernetes
• Kubectl
• Shared Persistent Storage - Option are GlusterFS, Ceph FS, AWS EBS, AzureDisk, etc.
• Python Application Source Code
• Dockerfile
• Container-Registry

Dockerfile

FROM python:2.7
MAINTAINER XenonStack

# Creating Application Source Code Directory
RUN mkdir -p /usr/src/app

# Setting Home Directory for containers
WORKDIR /usr/src/app

# Installing python dependencies
COPY requirements.txt /usr/src/app/
RUN pip install --no-cache-dir -r requirements.txt

# Copying src code to Container
COPY . /usr/src/app

# Application Environment variables
ENV APP_ENV development

# Exposing Ports
EXPOSE 5035

# Setting Persistent data
VOLUME ["/app-data"]

# Running Python Application
CMD ["python", "wsgi.py"]

Building Python Docker Image

$ docker build -t <name of your python application>:<version of application> .

Publishing Container Image

• Adding Container Registry to Docker Daemon

$ docker version
Client:
 Version:   17.03.1-ce
 API version:  1.27
 Go version:   go1.7.5
 Git commit:   c6d412e
 Built:     Mon Mar 27 17:14:09 2017
 OS/Arch:   linux/amd64 (Ubuntu 16.04)

$ sudo nano /etc/docker/daemon.json

{
 "insecure-registries": ["<name of your private registry>"]
}

$ sudo systemctl daemon-reload
$ sudo service docker restart

$ docker info

Insecure Registries:

 <your container registry name>
 127.0.0.0/8

• Pushing container Images to Registry

#!/bin/bash
pip install --upgrade --user awscli

mkdir -p ~/.aws && chmod 755 ~/.aws

cat << EOF > ~/.aws/credentials
[default]
aws_access_key_id = XXXXXX
aws_secret_access_key = XXXXXX
EOF

cat << EOF > ~/.aws/config
[default]
output = json
region = XXXXX
EOF

chmod 600 ~/.aws/credentials

ecr-login=$(aws ecr get-login --region XXXXX)
$ecr-login

Serverless Computing is Exploding

Serverless Computing

Serverless Computing Advances the way Applications are Developed

Monolith => Microservice => FaaS

• Creating a Deployment Package

• Uploading a Deployment Package

Database Integration For Your Application

• Install MongoDB and configure it to get started.

• Create Database EmployeeDB

• Create table Employee

• Insert some records into the table for the demo.

• Write a file “config.py” to setup configuration on the serverless architecture as shown below.

Continue Reading the full Article at: XenonStack.com/Blog

Serverless Architecture

What it means to have servers?

• Managing how the primitives (functions in the case of applications, or objects when it comes to storage) map to server primitives (CPU, memory, disk etc.).

• Own provisioning (and therefore paying) for the capacity to handle your application’s projected traffic, independent of whether there’s actual traffic or not.

• Own managing reliability and availability constructs like redundancy, failover, retries etc.

Advantages of going Serverless

• PaaS and Serverless - A user of traditional PaaS have to specify the amount of resources—such as dynos for Heroku or gears for OpenShift—for the application. The Serverless platform will take care of finding a server where the code is to run and to scale up when necessary.

• Lower operational and development costs - The containers used to run these functions are decommissioned as soon as the execution ends. And the execution is metered in units of 100 ms, You don't pay anything when your code isn't running.

• Fits with microservices, which can be implemented as functions.

How to migrate to a Microservices Architecture?

• One code per app/service: There is always a one-to-one correlation between the codebase and the service.

• Explicitly declare and isolate dependencies: This can be done by using packaging systems.

• Use environment variables to store configurations.

• Strictly separate build, release and run stages.

• Treat logs as event streams. Route log event stream to analysis system such as Splunk for log analysis.

• Keep development, staging, and production as similar as possible.

Microservices Architecture: Benefits

Microservices Architectures have lots of very real and significant benefits:

• Systems built in this way are inherently loosely coupled

• The services themselves are very simple, focusing on doing one thing well

• Multiple developers and teams can deliver independently under this model

• They are a great enabler for continuous delivery, allowing frequent releases whilst keeping the rest of the system available and stable

In this post, we will implement a Nexastack function which integrates with a database(MongoDB used here).

We are going to implement this new function in Java using Spring Framework. So, Let’s get started -

Employee Service

We are going to build an Employee Service consisting of a function to show Employees information from the database.

For Demo purpose we are here implementing one function “GetEmployee”.

1. Setting up MongoDB Instance 

• Install MongoDB and configure it to get started.

• Create Database EmployeeDB

• Create table Employee

• Insert some records into the table for demo.

• Write a file “config.properties” to setup configuration on the serverless architecture

 Continue Reading the full article at: XenonStack.com/Blog