Imagine You are part of a new web solution company trying to make it big in this cut throat market. There is a lot of competition and everyone is trying to deliver their products and new features before every other competitor does.
There are multiple teams involved in the success of your product:
- Your development teams are churning out sprints at a fast pace and are checking in code changes so that they can make a release on time.
- Your QA Teams are working round the clock to identify as many bugs as possible.
- Your IT team is making sure that your deployment servers are running full steam with utmost stability and reliability. They make sure that the infrastructure is scalable and standardized so that it can take the load of the client activities.
Everything Sounds Awesome. Correct?
Now comes the day when your product is finally supposed to be released. The development/QA teams huddle together, perform last minute integrations, tests, and minor changes before finally pushing the product to the deployment servers. Since there are new features in the release, a lot of system related changes need to be made in hosting servers so that there are no compatibility issues. This means you have to include your operations (Ops or IT) team to ensure that the servers are healthy and secure and can serve the customers with the new release.
What we witnessed above is a typical development and release scenario where you see a lot of last minute struggles, stress and, if things get worse, rollbacks. So let us list down the problems that we observed.
- During the entire sprint, the code was not tested once.
- Lack of co-ordination between Dev and Ops teams.
- Manual release process
- Last minute problems during release
- Many more which you may identify based on your past experiences.
The source of the above problems can be categorized into three broader categories:
- Lack of better development methodologies.
- Lack of automated system configurations by OPs team
- Lack of co-ordination between Dev and Ops team
Dev teams think this it is not their problem to manage and integrate the Operations environment (Servers etc.); all they worry about (rightly, though) is the timely release of their product. Similarly, Ops team rightly worries about managing the infrastructure and not about development related problems. Both the teams work in their silos and don’t interact with each other much.
This is exactly the problem which DevOps tries to solve. Devops doesn’t come as a technical solution. It is a methodology that brings together various other technical solutions, integrates them based on need.
The methodology consists of the below major theories:
- Development solutions
- Software Configuration Management / Version Control (SCM)
- Continuous integration (CI)
- Releasing solutions
- Continuous Delivery / deployment (CD)
- Infrastructure Automation
- Configuration Management (CM)
- Infra as Code
Let’s look at these theories one by one:
These tools provide solutions to common development methodology problems.
For example, Version Control provides a way to track all the changes which go into your codebase. It also provides multi-site/multi-user/multi-team collaboration on multiple software projects. Version control solves the problems of tracking changes, finding Bugs, and also code reviews in the software development process. Prime example of SCM tools are Git, SVN and perforce.
Continuous Integration (popularly known as CI) takes the features provided by version control to the next level. CI enables continuous code quality checks on the product during development. CI tools, like Jenkins, keeps a keen eye on the SCM tool. With continuous building, any new code change is subjected to compilation (and optionally various other code quality checks) to ensure that there are no compromises made with the quality of the code. Jenkins integrates with various SCM tools to enable this functionality. Continuous testing tests the compiled output of the building and performs preconfigured tests on the product. the tests can range from smoke/BAT tests to regression, functional and
performance tests. Tools like JUnit and Selenium are great examples of such tools. Releasing solutions consists of the delivery pipelines. Continuous delivery enables development teams to build/test the product and keep it ready for release with every change in SCM. One manual approval is required to actually release the product. Continuous Deployment gets rid of the manual approval and releases the product as soon as there is a new change (which passes the strict criteria of build, code quality, and tests)
The above two topics were related to development, especially on how to ensure that the software getting into your product is of top quality, verified for the same, and also ready to deploy. Now let us take a look at the services that help us in successful deployment.
Almost all the organizations have some sort of data center which consists of a large number of computing machines (or computers, to put is simply) for their computation tasks. Computation tasks may include compilation, testing or execution of scripts. One limitation that organizations face is that of the rigidity of the physical machines. To configure a physical computing node, it is difficult to scale them after a certain limit. Also, the utilization of physical machines is always questionable. Virtualization enables getting rid of these limitations. you can run many operating system hosts on a single physical machine. This enables highly efficient utilization of system resources. VMWare provides excellent solutions for virtualization. these solutions are also industrially accepted and are in high demand.
Another word buzzing around these days is containerization, which allows you to build your application, package them along with their dependencies into a container and then these containers can be easily shipped to run on other machines. These containers use containerization which can be considered as an evolved version of virtualization. The same task can also be achieved using virtual machines, however, it is not very efficient. An example here would be the Docker.
Keep visiting our website acadgild.com for more posts related to technologies and Certification courses.