cutimage - Fotolia
The modern enterprise application is defined by a complex ecosystem of hardware platforms, system software and application components, all of which dance with development, testing and IT operations. This entire setup is tied together by practices, tools and the admins applying them. So how do you ensure these pieces coexist successfully and approach them in an organized way?
Here are five application lifecycle management (ALM) best practices related to pipeline construction, tool sets and team organization -- all arranged around a single unifying repository, which is usually Git.
1. Unify the application lifecycle
The application lifecycle starts with development planning and ends in production deployment. Within it, the acknowledged steps are development, testing and deployment.
Most businesses have organized these three major steps with automated tasks, but have not truly integrated them. One ALM best practice is to unify the complete application lifecycle from development to production. To do that, think of applications as units of logic.
A unit of logic has a business goal, a set of software components to achieve that goal, a hardware and software platform to host those components, and a framework for deployment to support workers and decisions. Code is part of that, but the platform configuration and the software parameterization are equally important. These elements must accompany each unit of logic throughout the pipeline to deployment -- that's where GitOps comes in.
GitOps is the use of a repository -- frequently with Git as the underlying technology -- to store everything about an application throughout the pipeline, from development planning through testing and deployment. The repository serves as a single source of truth that enforces consistency in and across each step in the software's progression -- such that parameters match code, for example.
Additionally, companies tie in infrastructure as code by holding all the deployment data in the repository linked to versions of the application code. Users report that, in particular, linking infrastructure as code to GitOps is critical in the testing phase, as it ensures the operating parameters carry into production correctly.
2. Remove team silos
To further promote ALM best practices, treat the development, testing and operations teams as a single unit. If your organization can't establish common management, it must create a management committee that's responsible for GitOps and the surrounding tools and practices. A repository only serves as a single source of truth if everyone uses it properly.
Integrate project teams around a toolkit that enforces policies. IT's integrated development environment should always pull code from the repository and return it there, but should also pull configurations and operating parameters the same way, using common versioning so that each code element is linked to its proper setup. The whole package must accompany code through testing and deployment, which ensures that the development project is integrated from start to finish.
GitOps is frequently paired with Kubernetes container orchestration to create a declarative model; for example, the Kubernetes controller exposes an intent-modeled API that declares a deployment goal state and operates on it rather than on the underlying parameters and elements. This won't expose details that create vulnerabilities and inconsistencies in a deployment, enhancing application stability.
3. Establish goal states
Focus management and monitoring practices on DevOps-ready configuration management, container management and infrastructure-as-code tools that can enforce goal states.
Declarative models help teams discover how code has deviated from the declared goal state. Use the diff feature in these tools -- some examples include kubectl diff for Kubernetes and the --diff option in Ansible playbooks -- to compare current and goal-state conditions and alert you to differences.
Jenkins is a common automation server to integrate CI/CD with a repository, with competitors such as Integrity, GoCD or GitLab CI/CD. When choosing a tool, ensure that it will integrate with your organization's repository to maintain that single source of truth.
There are broad management toolkits available for IT organizations that don't create tool integrations internally. For example, Weaveworks offers an integrated tool and a GitOps-centric distribution of Kubernetes, and it recommends and supports tool integrations for the latter. Diamanti and Rancher Labs have similar container platform capabilities.
Start a GitOps approach to enterprise application support with a review of the components and capabilities of a managed toolkit, then weigh the benefits of a single-source option or put together a collection of tools to meet your specific requirements.
4. Deepen resource pools
Enterprise applications only run successfully if they have a reliable server resource pool and virtualization strategy. Application-specific servers and systems invite outages, while resources in a shared pool enable applications to fail over and scale as needed.
Public cloud hosting augments data center resources, particularly on the applications' front ends, but many businesses prefer to host core application resources internally. Many organizations also prefer their OSes and middleware tools to be part of a preintegrated package with support.
5. Open communication lines
Integrate every application lifecycle management, testing and test data generation, deployment and monitoring tool into a single, structured workflow. The whole IT team must ensure pieces integrate fluidly and perform as desired throughout changes to tool versions, business development needs and personnel.
Attempts to structure teams around ALM best practices won't work in a vacuum: Organizations have the best chance to manage the team and interplay between the team and technology if they apply these points in the order of presentation outlined here.