Month: February 2017

Continuous delivery is a method that promotes the adoption of an automated deployment pipeline to quickly and reliably release software into production. This method comes from the agile school and is a natural partner to the DevOps movement.

The goal of continuous delivery pipelining is to establish an optimized end-to-end process, enhance the development to production cycles, lower the risk of release problems, and provide a quicker time to market.

Break it Down to Build it Up

In one of my previous blog posts, I listed Jez Humble’s 8 Principles of Continuous Delivery. In order to achieve the Holy Grail of an “automatic, high quality, repeatable, reliable, continuously improving process”, you must first break that process into simpler component practices.

Building the “pipeline” in this way will enable you to deal with the different stages of the process, one by one.

A deployment pipeline makes sure a change is processing in a controlled flow. The system is as follows:

• A code check-in or configuration change triggers the flow
• The change is compiled
• The database changes goes through a set of tests – usually unit tests and static code analyses
• Passing that set of test triggers automatic application tests and regression tests

After successfully passing these tests, the change can be either ready for production use, or go through additional manual and user-acceptance tests before hitting production.

The Continuous Delivery Pipelining Checklist

Achieving an efficient deployment pipeline is done by following these best practices:

1. Build your binaries only once: Compiling code should only happen once, eliminating the risk of introducing difference due to environments, third party libraries, different compilation contexts, and configuration differences.
2. Deploy the same way to all environments: Use the same automated release mechanism for each environment, making sure the deployment process itself is not a source of potential issues. While you deploy many times to lower environments (integration, QA, etc.) and fewer times to higher environments (pre-production and production), you can’t afford failing deployment to production because of the least tested deployment process.
3. Smoke-Test your deployments: A non-exhaustive software test (essentially testing “everything” – services, database, messaging bus, external services, etc.) that doesn’t bother with finer details but ascertains that the most crucial functions of a program work, will give you the confidence that your application actually runs and passes basic diagnostics.
   
   
4. Deploy into a copy of production: Create a production-like or pre-production environment, identical to production, to validate changes before pushing them to production. This will eliminate mismatches and last minute surprises. A copy of production should be as close to production as possible with regards to infrastructure, operating system, databases, patches, network topology, firewalls, and configuration.
5. Instant propagation: The first stage should be triggered upon every check-in, and each stage should trigger the next one immediately upon successful completion. If you build code hourly, acceptance tests nightly, and load tests over the weekend, you will prevent the achievement of an efficient process and a reliable feedback loop.
6. Stop the line: When a stage in the pipeline fails, you should automatically stop the process. Fix whatever broke, and start again from scratch before doing anything else.

The pipeline process helps establish a release mechanism that will reduce development costs, minimize risk of release failures, and allow you to practice your production releases many times before actually pushing the “release to production” button.

In Short: the Logic

Continuous improvement of the automated pipeline process will ensure that fewer and fewer holes remain, guaranteeing quality and making sure that you always retain visibility of production readiness.

Making sure your database can participate in the efficient deployment pipeline is obviously critical. However, the database requires dealing with different challenges than application code. Implementing continuous delivery for the database proves to be a challenge.

As a DBA, managing your company’s valuable data is a primary concern which you must balance with your day-to-day responsibilities.

This includes continuous installation, configuration, migration, and updates to the database. Ultimately, any problems that arise with the database fall onto your shoulders – along with the responsibility to mitigate risks and implement fixes as quickly as possible.

With constant pressure for technology companies to release frequent updates to applications, overcoming common challenges in database development lifecycle management is always a concern.

Implementing DBLC Solutions

Here are 5 database lifecycle management capabilities, which offer highly efficient ways to manage the database schema, data, and metadata for a database application.

By implementing these solutions, you will spend less time retracing steps or wasting time tracking down information and documentation, which are unnecessary and expensive.

1.  Effective Risk Mitigation

A Three-way Analysis mechanism highlights database conflicts, enabling you to detect and respond to requested changes and to protect corporate information. This analysis provides a valuable alternative to damage control, comparing objects between environments and generating the proper commands to reflect the change.

A three-way, Baseline-Aware Analysis, goes beyond the capabilities of standard compare-and-sync tools. It identifies not only that configuration drift exists, but where the changes originated and whether they’re safe to deploy. This mitigates one of the most prominent risks faced by DBA Managers attempting to implement continuous delivery for the database.

This allows you to save a snapshot of the database schemas and lookup content before and after successfully rolling out any version. These snapshots can be used as a golden copy and act as a baseline when generating the next release’s database build script.

2.  Business Agility Made Possible with a Deployment Manager Wizard

DBAs should automatically generate the build script (deploy, promote, or upgrade script) based on Change Requests (CR) or business requirements.

This enables anyone to generate the database build script with a few mouse clicks and select the objects being analyzed based on several different criteria, such as: application versions, labels, object type, object name, Change Request (CR), related to business requirement requests, and so on.

By creating the database build script, you can drastically reduce the preparation phase in the release cycle and ship out rapid changes to satisfy the ever-increasing demands for leaner, more agile development cycles.

This business agility is often sought after but rarely achievable when it comes to database development due to the challenges faced with continuous delivery for the database. The preparation phase should be reduced from days and weeks to just minutes and hours.

3.  Improve Development Collaboration and Gain a Complete Audit Trail History

An efficient check-in, check-out process prevents any team member from making changes to database objects or content without first checking the item out. The check-out process locks the object for access by other team members, preventing two development teams from making simultaneous changes to the same objects.

Development collaboration is drastically improved by avoiding out-of-process changes that create conflicts and issues later in the development lifecycle.

When an object is checked in, the developer is prompted to enter the reason for the change, with everything else automatically documented, including who made the change, where, and when – creating a complete audit trail to improve compliance and database governance.

4.  Support for Policy-Based Database Development and Deployment

One of the major challenges for DBA Managers is to differentiate Roles & Responsibilities when it comes to the database. DBA teams can’t deal with code review, but are left to deal with damage control when things break.

The right support regarding Change Policy Enforcement also enables you to harness your Active Directory policies and impose them on the databases in every environment.

For example, you can give developers full access in the development environment and a read credential in the testing environment (if required for debugging purposes), but restrict them from the structure and lookup content changes in the User Acceptance Testing (UAT) and the production environments.

5.  Automation and Collaboration

Boost overall developers and DBAs productivity by 20% through automated processes and collaboration functionality. Also, it helps create a competitive advantage and a Shorter Time-to-Market while reducing time for managing changes.

Database Lifecycle Management: On Point, On Demand

At the end of the day, you need to be the master of your database domain — and that extends to every aspect and phase of lifecycle management. To get the most out of your database, it’s imperative that you maintain strict adherence to well-defined and thoroughly adaptable database change and release policies across all 5 database lifecycle phases — requirements analysis, logical design, physical design, implementation, monitoring and maintenance.

It’s important to bear in mind that the lifecycle is just that — a cycle. It doesn’t necessarily end and you should be prepared to move between lifecycle phases in as fluid and streamlined a manner as possible. Be sure to clearly delineate and enforce roles and responsibilities across every permutation of the database, starting from the pre-development stage.

For DBAs, protecting your company’s valuable data is a primary concern. Having database lifecycle management capabilities can significantly reduce the need for costly delays, application glitches, and backouts.

From streamlining  workflow to providing automated change history tracking, database release automation, and automated merge and build, all with a single source of truth you can trust, simplifying the day-to-day responsibilities of DBAs with complete database lifecycle management capabilities will help avoid unnecesary, time consuming, and expensive delays.

Enjoyed this article? Find out what are the best practices for database management in our next article.

Agile methodology seeks to transform the functional norms that define your IT operation. When properly executed, it will also transform your business outcomes. Of course, a true embrace of agile cannot be accomplished with a mere checklist; it requires a cultural mind shift from the agile CIO down to the entire organization.

In an effort to bottle that transformative capability, Gartner distilled the most crucial and elusive concepts/tactics of agile into 10 basic maxims. Desiring to make those insights more accessible and more consumable, I’ve taken the liberty of recreating that seminal article in graphic form.