A community of more than 1,600,000 database professionals and growing

I've been re-reading the book, Continuous Delivery, as part of the current San Diego Technology Immersion Group monthly meeting track. This book was the focus of the first meeting in May, and will continue for the next couple months. Continuous Delivery and the related, DevOps, are fascinating concepts, but mostly I find the discussions really interesting for me to see and hear how others view the DevOps, Continuous Integration (CI), and Continuous Deliver (CD), and where they apply in each person's organization.

One of the things I've noticed is that lots of people get overwhelmed with DevOps. They hear stories of how others are running an extremely efficient software development shop and think they couldn't implement CD in their organization. Or they think that CI/CD/DevOps is just a way of building software that's so far removed from their own experience. However, DevOps isn't really anything new or special. It's not even one thing, as there are many divergent views of what DevOps means. However, plenty of people have been applying and adhering to the various definitions of DevOps for decades, just viewing their process as efficient, effective, and empowered.

I use DevOps and CD somewhat interchangably, as they often proceed along the same path and each is a intertwined with the other. Note that going to a CD process doesn't mean that you release every day/hour/whatever. If means that you release when you want, which could still be every few months. It's just that you have a process set up to allow smooth process flow.

As I talk to people who are looking to build a DevOps process, and I hear about more and more of them all the time, one thing I stress is to take things slow. You won't build your DevOps process, whatever that looks like, this month. In fact, what you should expect to do is learn as you go, and whatever your vision of the process is today will change. You will learn, grow, change the way you do some things, and also change the way you implement new processes, even if you're copying how other companies have implemented their own system.

Most importantly, what I try to stress is to slowly move to CD (or DevOps). Look at the process you have now and just change one thing. Let's imagine that you:

• manually track changes to the database in email
• then build a change script manually
• then have a DBA apply those changes
• then let QA run tests with an application
• then modify the script that goes to production

Leave that process as is. Let's implement one thing. Add some version control that will let you build a base for other changes. Your new process would be (changes in bold).

• manually track changes to the database in email
• then build a change script manually
• store the change script in a VCS
• then have a DBA apply those changes
• then let QA run tests with an application
• then modify the script that goes to production

Or change to this instead?

• manually track changes to the database in email
• then build a change script manually 
• then have a DBA apply those changes 
• then let QA run tests with an application 
• then modify the script that goes to production
• track all changes to production in an automated fashion (hopefully using a tool)

Over time, you can make another step. Maybe you use something like SQL Source Control or ReadyRoll to build change scripts and put them in a VCS. Or perhaps you build a process that takes the changes from the VCS and applies them to a test database without requiring the DBA to check things out and execute them. Both are valid ways to evolve your process. (Disclosure, I work for Redgate Software, maker of those products). I'm giving you a few suggestions here, but there are multiple ways, methods, and tools you could use.

And that's the key. You evolve your process, evolve your communication, learn to work together to accomplish goals. Not big goals, little goals. Add small items to your process as you realize they can be automated. Change communications in ways that help ensure everyone knows where to find code and how to deploy it. Or everyone knows how to set up environments (hopefully automated).

Slowly get better and better, and before long you'll find that you can make changes in smaller batches, and ensure those changes can be deployed at a rapid pace. Or maybe you'll have confidence to begin moving to a feature flag architecture so that you deploy changes well in advance of users being aware of them. Note, they're not perfect or the solution.

DevOps is about learning and growing. This is really the same basic principles that have driven Six Sigma and Kaizen and various other philosophies that recognize that we can do better over time. Make small steps, measure, learn, and improve.

Join the debate, and respond to today's editorial on the forums

The way to do this is mark each procedure as a startup procedure with sp_procoption. You could use one procedure to call the other three, but you do not have to do this.

Ref: sp_procoption - https://msdn.microsoft.com/en-us/library/ms181720.aspx

» Discuss this question and answer on the forums