Software Defined Security

 

 In the virtual world an organization might have thousands of virtual machines... The organization cannot manage them manually. That's where the Software Defined Security comes handy. Applying security policy uniformly and automatically in all environments.

 

 With runtime virtualization, different containers/VMs can reside together in the same cloud infrastructure – and have different security protections. Each application can have a different security profile. A software bases security solutions helps automate secure deployments in clouds and allow for customization of protection across different applications

 

 In a hybrid cloud environments, applications can span across multiple clouds – and yet have an uniform security settings and responses. Automate responses to security events to minimize damages and increase vigilance with automated monitoring.

Software Architecture for Cloud Native Apps

Microservices are a type of software architecture where large applications are made up of small, self-contained units working together through APIs that are not dependent on a specific language. Each service has a limited scope, concentrates on a particular task and is highly independent. This setup allows IT managers and developers to build systems in a modular way. 

Microservices are small, focused components built to do a single thing very well.

Componentization: 
Microservices are independent units that are easily replaced or upgraded. The units use services to communicate with things like remote procedure or web service requests.

Business capabilities: 
Legacy application development often splits teams into areas like the "server-side team" and the "database team." Microservices development is built around business capability, with responsibility for a complete stack of functions such as UX and project management.

Products rather than projects:
Instead of focusing on a software project that is delivered following completion, microservices treat applications as products of which they take ownership. They establish an ongoing dialogue with a goal of continually matching the app to the business function.

Dumb pipes, smart endpoints: 
Microservice applications contain their own logic. Resources that are often used are cached easily.Decentralized governance: Tools are built and shared to handle similar problems on other teams.

Problems microservices solve

Larger organizations run into problems when monolithic architectures cannot be scaled, upgraded or maintained easily as they grow over time.

Microservices architecture is an answer to that problem. It is a software architecture where complex tasks are broken down into small processes that operate independently and communicate through language-agnostic APIs.

Monolithic applications are made up of a user interface on the client, an application on the server, and a database. The application processes HTTP requests, gets information from the database, and sends it to the browser. Microservices handle HTTP request response with APIs and messaging. They respond with JSON/XML or HTML sent to the presentation components.

Microservices proponents rebel against enforced standards of architecture groups in large organizations but enthusiastically engage with open formats like HTTP, ATOM and others.As applications get bigger, intricate dependencies and connections grow. Whether youare talking about monolithic architecture or smaller units, microservices let you splitthings up into components. This allows horizontal scaling, which makes it much easier tomanage and maintain separate components.The relationship of microservices to DevOpsIncorporating new technology is just part of the challenge. Perhaps a greater obstacle is developing a new culture that encourages risk-taking and taking responsibility for an entire project "from cradle to crypt."

Developers used to legacy systems may experience culture shock when they are given more autonomy than ever before. Communicating clear expectations for accountability and performance of each team member is vital. DevOps is critical in determining where and when microservices should be utilized. It is an important decision because trying to combine microservices with bloated, monolithic legacy systems may not always work. Changes cannot be made fast enough. With microservices, services are continually being developed and refined on-the-fly.

DevOps must ensure updated components are put into production, working closely with internal stakeholders and suppliers to incorporate updates. Microservices are an easier solution than SOA, much like JSON was considered to be simpler than XML and people viewed REST as simpler than SOAP.

With Microservices, we are moving toward systems that are easier to build, deploy and understand. 

Serverless Computing is ideal for IoT with Edge & Cloud Computing

Serverless Computing for Microservices

Microservices is a new architecture of developing software. Microservices is best defined as:

"Service Oriented Architecture composed of loosely coupled components that have clearly defined boundaries"

This can be interpreted a set of software functions that work together based on predefined rules for example take a restaurant website. A typical restaurant website does not have high traffic all through the day, and traffic increases during lunch & dinner time. So having this website on a dedicated VM is a waste of resources. Also the website can be broked down into few distinct functions. The main webpage would be the landing zone, and from there each section like Photos, Menu, Location, etc., could be another independent function. The user triggers these funtions by clicking on the hyperlinks - and users will be served with the requested data.

This implies no coupling or loosely coupled functions that make up the entire website and each funtion can be modified/updated independently. This implies, the business owner can independently - without the need to bringdown the entire website.

From cost prespective also, building a website with Function-as-a-Service - allows the business to pay for the actual usage and each segment of the site can scale independently.

Containers Vs Serverless Functions

Today, Containers and Functions are  "very hot" among the developer community. If you are using Fission, Serverless Functions run inside a container and this creates some confusion among young developers and students. As an expert in latest computing architectures and solution, I got too many questions on what exactly is the difference between the two?

In this post, I have posted the key differences between the two and the differences are not very clear cut in some aspects such as scaling and management, but at least here are some major differences and hope this gives you a better understanding of how containers and Serverless functions work.

Advantages of Serverless Computing

Use Cases of Serverless Computing

Serverless Computing on Common IT Infrastructure

 Customers want flexible deployment options. In this configuration, IT can offer hosting traditional apps – running on VM. In addition, Container based workloads can be deployed on the same underlying infrastructure. The Openstack orchestration frameworks like Kubernetes and Cloudfourms allows great level of flexibility.

On top of Kubernetes cluster, one can also deploy Fission – to create a serverless IT servers to support new IoT & Mobile apps based on-demand services, while retaining a single plane of glass for management APIs – while providing unified multi-tenancy mechanism.

This unified platform provides IT to offer all three application deployment options: Traditional business applications running on VMs; Container Apps and Serverless Computing platform.

Customers want flexible deployment options. In this configuration, IT can offer hosting traditional apps – running on VM. In addition, Container based workloads can be deployed on the same underlying infrastructure. The Openstack orchestration frameworks like Kubernetes and Cloudfourms allows great level of flexibility.

On top of Kubernetes cluster, one can also deploy Fission – to create a serverless IT servers to support new IoT & Mobile apps based on-demand services, while retaining a single plane of glass for management APIs – while providing unified multi-tenancy mechanism.

This unified platform provides IT to offer all three application deployment options: Traditional business applications running on VMs; Container Apps and Serverless Computing platform.


Open source Serverless framework - Fission uses Kurbernetes to manage the serverless functions: Creation, Termination and if needed, parallel invocation of apps. While it is a major technological breakthrough - it is also a very important financial innovation on how compute resources are being offered over the cloud.

Kubernetes event handlers is used to create custom automation in form of backend APIs or Webhooks. Kubernetes cluster manager will then manage the backend delivery based on demand.

I expect to see a significant disruption of cloud service offerings with this serverless computing.

In my next few upcoming blogs, I will write more about the software layers and architecture needed to offer serverless computing.