Somebody
correctly said, “There are no legacy
systems, just legacy thinking.” The fact is there is always resistance to change
howsoever smaller the change may be. This is normal human tendency. People
always try to compare things with open systems. There is always room for improvement
from executers as well as legacy space workers to understand the need for
quicker and continuous Integration and continuous Delivery, there needs to be
some genuine appreciation of legacy architecture and the need to work in collaboration
to achieve the DevOps framework and want to transform the organization to the
highest level of automation.
Architectural Constraints
Yes, it’s a
hard truth that there are architectural constraints while dealing with legacy
systems as they are static and very tightly coupled. We implemented batch jobs
and schedulers in our legacy systems. There are many processes in our legacy
systems which continue to take long hours and are dependent on various
architecture layers. For example, Environment provisioning is dependent and
takes a long time in legacy systems. There are constraints which keep the environments
dependent on toolchain upgradation and are heavily environment dependent. With
no containerization and very poor portability legacy systems are very tough to handle.
But the fact of the matter is all these issues are solvable but require a lot
of collaboration and the implementers should keep in mind that their changes
are making sense keeping the business logic in place.
Toolset Implementation
Implementation
of toolset is always difficult to handle in a legacy system, but the key is to
understand the needs and modularize the problems. We need to achieve automation
in modular level first and then try to achieve complete automation. Step by
Step automation and tool chain setup needs to be done by implementers and should
take care that each stage makes sense.
Rather than
tool first approach or forcing tools on people, the implementers will have to
take the path of people first and culture first approach. We will first have to
make sure our people understand the needs of the hour and then make sure we
create a culture of continuous improvement and then we can embrace the devops
framework and ask people to choose from our set of toolset.
How to Achieve CI
and CD
maturity
For legacy organizations to move
to DevOps framework there must be a policy set up and targets needs to be set
up to achieve and each target should have a measurable progress. There are some
measurable points that are being listed here and are very important for
implementers to understand that they should achieve before going live. There are a few
reasons why robotized testing is fundamental to ceaselessly conveying an
incentive to the client. The first is that computerized tests give an
executable of the prerequisites of the application highlight being produced. We
know we have composed the correct code, not because it arranges, but rather because
it does what the test determines it will do. This early criticism can be at the
unit/module level, the reconciliation level, the end-to-end utilitarian level
which is regularly utilized as acknowledgment tests from the client viewpoint,
and the heap and execution level. So let’s have a look at the important points
which we take care in mind while moving from legacy set up to DevOps implementation:
· Are
the resources properly utilized?
· Is
the Environment modularized and containerized and made portable?
· Is
continuous Integration in Place making sense to the final deployment
· Is
Automation Testing Framework in place?
· Is
the testing framework making sense?
· Are
we monitoring our matrices?
·
Have we set targets for future to
achieve in terms of quality?
Refactoring
legacy applications for containers and microservices
Another Crucial point to
consider while moving from legacy systems to devops framework is to check whether
we can make use of containers and microservices. The
best and easiest way of containerizing is done via various tools like Docker,
puppet and chef. These tools bring portability to applications and can run in
self-contained units. With it you can containerize Operating systems, Applications,
Environment variables as well as the tool chains. These in integration with CLI
tools provides enormous impact on dev teams. With these you remove the phrases
like it was working on my computer and I don’t know why it’s not working on
your system. But again, there are certain points you need to take care in mind
while implementing in legacy infrastructure
·
Check
if we can re factor old applications or can write from scratch.
·
Check
the design first before containerizing them.
·
Decouple
the data from application layer.
·
Break
application into components.
·
Build
data as a service.
·
Even
if our application is portable now, is that making sense according to business
logic.
· Legacy systems often lie on the same
set of servers with access restrictions.
Nothing is Impossible
DevOps in the legacy framework is certainly
not going to be very smooth, but it is certainly not a mission impossible, If
we take care in mind the below points and start working on the basics first we
can easily achieve portability and achieve some maturity in DevOps framework.
Here are the points we need to start from:
- Testing
Framework Automation.
- Selecting
strategies for building out code coverage.
- Creating
portable environments and loosely coupled infrastructure.
- Investing
in cloud technologies
- Select
the tools that makes sense according to the needs
- Integrate
unit tests with the build system and deployment strategies
- Train
staff how to perform automated unit testing and utilize the reports.
These are all vital points in enhancing legacy framework
testability and in moving to a Continuous Delivery demonstrate. So, I am going
to say it again DevOps implementation
here will be difficult, but it is certainly not a mission impossible. Taking
the above points in mind we are taking a monolithic application which is very
tightly coupled and turning it into something that’s portable and the
achievements are measurable with automation maturity which is meaningful and take
people first approach.
