Linnovate CALM (Cloud Application Life-cycle management)

You are here

Contact

Israel Office

+972-52-838-7222

+972-52-430-5252

Europe office

+33-695-805-004

22.04.2017
Linnovate CALM (Cloud Application Life-cycle management)
submitted by: admin
In Linnovate’s years of operation, we find that some of the best value that we can deliver clients we work with is the ability to import our development methodologies and jumpstarting the clients’ dev-ops and ALM (Application Lifecycle Management) practices.
 
Linnovate CALM (CALM) is a set of predefined processes that start in the development and go through different phases of testing, deployment, maintenance, business insights and SLA spanning across an entire lifecycle of a software product.
 
Throughout the CALM process, each of these steps is monitored and controlled, followed by proper tracking and documentation of any changes to the application.
 

Requirements/Specifications


The first step is to interview the client and learn about his applications needs, bottlenecks and current architecture, we discuss the current release strategy and the associated pain points in the client's current process.
 

Development

 

Source Control

The code is managed by git in Github, Bitbucket, local or remote Gitlab.
Guidance is provided in the proper use of the SCM’s various features such as branching, tagging, releases, code review, wiki-based knowledge management and more.

 

 
 

Gitflow

 
Gitflow is instructed and integrated with the CI process that is bound to the dev, stage and production branches.
Gitflow provides a proven strategy of how to approach the various stages needed.
 
 

CI/CD

Jenkins is used with the relevant plugins to be aware of interactions with the tracked branches in the Git repository
Jenkins provides the central hub which is in charge of running the “build” which might run tests, deploy the code upon success and notify the team through the notification service used.

 

Testing

 

Notification Service

Rocketchat/Slack/Hipchat/Teams is used to provide a central location for all of the client's notification and form of radically improving project transparency and communication.

 

 

Dockers

Modern applications tend to transform from larger monoliths to microservices architecture - creating slim stateless microservices devoted to one single task and thus enabling the client to scale the specific area in the application which has a bottleneck. This leads to radical costs saving derived from much better use of the available infrastructure. The latest trends regarding hosting microservices lead to the use of Dockers.


Based on the architecture that was specified and discussed we segment the application to smaller parts and host them within scalable Dockers.

 

Summary

 

 

Stage

Development

1.      Architecture review

2.      SCM (github/bitbucket)

3.      Gitflow

4.      Jira integration

5.      Notifications basic (bitbucket, jira)

6.      Basic Training

Testing

1.      Push to branch invokes “build

2.      Jenkins test invocation

3.      Notifications integration

4.      Basic Training

Deployment

5.      Jenkins (basic)

6.      Dev environment auto deployed from dev push

7.      Docker based implementation

8.      Rancher based docker orchestration

Maintenance

1.      Centralized logging using ELK stack

2.      Docker monitoring using Prometheus/Grafana

3.      Notifications integration

4.      Backups

5.      Basic Training

Business Insight

1.      Implement custom dashboard to provide insights regarding the business KPIS

SLA

Support and maintenance for your application

 

tags

Comments

Add new comment

blogs