There are lots of tools of technologies comes under DevOPS Practice. But majorly devops focused on these 7 key aspects
- Code — Code development and review, version control tools, code merging.
- Build — Continuous integration tools, build status.
- Test — Test and results determine performance.
- Package — Artifact repository, application pre-deployment staging.
- Release — Change management, release approvals, release automation.
- Configure — Infrastructure configuration and management, Infrastructure–as–Code tools.
- Monitor — Applications performance monitoring, end–user experience.
DevOps: A Cultural Change for the Win https://dab1nmslvvntp.cloudfront.net/wp-content/uploads/2016/09/1474959371devops.png
- Accelerated time-to-market: shorten the time it takes from when an idea is conceived until it’s available for sale or in production.
- Building the right product: developers get faster feedback from users with more frequent releases and live testing of ideas (more on this later on the “A/B Testing” section).
- Cost reduction: reports average a 20% reduction.
- Improved productivity: with continuous delivery, developers and testers save time setting up and fixing their working environments. Also, deployments are significantly faster (more on this later in the “Continuous Integration with Jenkins” section).
- Reliable releases: with smaller and more frequent releases, the changes in code — and therefore the bugs introduced and their impact — are also smaller.
- Improved product quality: companies report a very significant reduction in open bugs and other issues (in some cases, by more than 90%).
- Improved customer satisfaction: this is, not surprisingly, a byproduct of all of the previous improvements.
-
Automated Build and Release
- Though automated nightly builds and smoke tests have been done even in a classic software development environment, such efforts were custom and scripted. The availability of automation platforms such as Hudson and Jenkins standardized such processes. The lead time to deploy changes in production has been minimized as a result.
-
Configuration Management
-
This is a very generic term that previously referred to source code control systems (CMS), but in DevOps context, it refers to automation to define and create system components or roles. Though system components are largely software, in virtualized environments, the provisioning of hardware components such as virtual machines and storage volumes are very much in the scope.
-
A typical provisioning of a compute node for a system component or role can start with creating a virtual machine, setting up user accounts and access privileges, and installing baseline software bits specific to that role.
-
-
Deployment Automation
- Most of the time, deployment automation is tied to configuration management or build and release infrastructure. While configuration management takes care of the baseline setup required for a system component, deployment automation addresses automated processes in getting the application software releases and patches installed on various types of compute nodes regularly. For example, Jenkins integrated with a CMDB system can be used to provision baseline compute nodes for a system component, and the same infrastructure can be used to push code incrementally to same compute nodes as part of the Continuous Integration process.
-
Monitoring
- The last thing that the providers of SasS and web consumer apps want to do is get notified of production issues by client users. The SaaS providers lose credibility and web portals lose ad revenue if features don't work as intended. Even though highly reliable monitoring systems are available, it is impossible to catch all of the issues using out-of-the-box features of such products. Extending the features based on domain knowledge of the application is the key to getting notified of potential issues before customers find it, and that requires a broad set of skills (mainly, scripting and knowing how to consume a wide range of native and REST APIs provided by the third-party tools used and the application being monitored).
-
Operational Intelligence
- A well-instrumented software system can leave tons of information about health and performance, and aggregating such info for troubleshooting and reporting can be a daunting task. Besides gathering info for management reporting, insights into the working of the system can also help improve performance and fine-tune operability, which ultimately contributes to the increased availability of systems.
An integrated tool ecosystem helps achieve the following:
- Real-time collaboration between development, delivery, and operations tools.
- Continuous planning from requirements capturing and review to design and code analysis.
- Cross-tool traceability for defining relationships between various data objects.
- Test strategy implementation for continuous testing.
- Continuous Integration through automatic triggering of build on successful completion of code check-in.
- Continuous testing through workflow based automatic triggering of both manual and automated test cases.
- Schedule based test automation script execution enabling Continuous Delivery.
- Continuous monitoring of release quality through reports and dashboards.
- Automated defect identification and resolution for faster HelpDesk response.
- End-to-end traceability providing better release predictability and change impact analysis.
- Meaningful reports, metrics, and KPIs for quick decision-making.
- Continuous Delivery through tracking release pipeline.
Here are the benefits stated in the diagram in text form:
- Immediate start after check-in: no wasted time
- One new change per new pipeline: transparent debugging
- Parallel execution: faster feedback
- All stages e.g., code analysis used as enforceable gates: easy to enforce quality controls
- Can include infrastructure / environment build as well as application deployment: predictable and consistent behavior
- Visible project status: easy to understand current stage of delivery execution
- If a stage fails, the committer of the change can be immediately notified: efficient communication
- Fully automated: predictable outcomes and minimized manual effort
- Consistently executed automated test harness: high visibility of code quality and automated test stability
- Easy to drill down to cause of failure: faster debugging
- Highly visible historic information: can extract trends which inform planning decisions
- Tested build package re-used: predictable and consistent behavior
- Environments are recreated from version control so no need to limit: efficient debugging
- Infrastructure resources recycled: efficient use of cloud services
- Some stages may only be triggered manually: compatible with release management approval processes
- The pipeline runs successively slower and more expensive quality gates: ensures optimized fast feedback
- Faster iteration It gets new features out faster and at higher quality.
- Faster, more user-friendly software that delivers value more quickly thanks to automation. Operations becomes part of the engineering applications team enabling the faster development and deployment.
- A repeatable process where every member of the team knows where everything is in the process and each team member knows their role. Reliable path, more stable releases, faster. Some manual work with app stores like publishing and beta but documented.
- The value the customer gets from the end product. Metrics like mean time to deploy, create, ship features, recovery, and root-cause analysis. Better software, more frequent releases, happier customers, and happier employees.
- The false promise of Agile is to develop more quickly. Long-term, it is faster because you are focusing on business value and building what is really needed and wanted rather than building some shiny new technology. Focus on what both internal and external customers need and begin troubleshooting from day one. Give customers better quality and business value.
- Development understands what operations is like, so they make choices that help rather than hinder, and vice versa. Continuous or at least rapid/pushbutton deployment so that fixes and features can be rolled out more quickly.
- Reduce cycle time, increase velocity of application delivery for apps, self-serve capabilities with no roadblocks. Increase the quality of what delivering and how to engage with customers in better ways, everyone understands the role in delivering something better for customer testing, certification, validation. Better teamwork equals better products. 3) Helping developers and ops team understand the impact they have on the business. More of the mindsets of the DevOps professionals use a closed feedback loop to know how to move the business forward. Planning through customer engagement with a view throughout the process.
- Speed to market. Coming out with features that are meaningful to customers. Start with the minimum viable product, get customer feedback and quickly iterate to meet customer needs. This reduces wasteful development. 30% improvement in customer satisfaction. Ten times increase in innovation velocity. 2X efficiency increase. 85% test automation. EA feedback from months to weeks. Developer feedback from weeks to minutes.
- DevOps automates a lot of the tasks of developers. Allows developers to focus on functionality and quality to provide a better UX and fewer bugs. Focus on what’s important not running deployment.
-
- Increase speed to market by having different teams come together. 2) If we implement correctly you increase release quality, release faster and learn. 3) Reduce testing costs because you don’t need to test after release. Customers are using AWS with automation feature scripts to check the capacity of servers. You know the impact of code of making changes running tests on AWS before you deploy scripts and automation to manage costs.
- Continuous delivery more than DevOps. Faster delivery with shorter feedback loops. Usability and user experience is more important. Get features out more quickly. Usability is the main driver.
- Higher quality releases. Another step in the release process. A mix of people and expertise adding an additional perspective to the release process to enhance the speed and quality of releases and freeing the developer to focus on the code of the product. Having greater awareness from all sides results in higher quality releases with automated processes that validate the accuracy and security of the code.
- Able to move forward with confidence when deploying code – from framework capacity to reliability. Deploy code with fewer surprises thanks to increased visibility into processes, tooling, and accountability.
- Increased visibility with DevOps encourages and enables more people to collaborate and iterate much faster.
Continuous Integration (CI) is a software practice that require developers to commit their code to the main workspace, at least once, possibly several times a day. Its expected that the developers have run unit tests in their local environment before committing the source code. All developers in the team are following this methodology. The main workspace is checked out, typically after each commit, or possibly at a regular intervals, and then verified for any thing from build issues, integration testing, functional testing, performance, longevity, or any other sort of testing.
The level of testing that is performed in CI can completely vary but the key fundamentals are that multiple integrations from different developers are done through out the day. The biggest advantage of following this approach is that if there are any errors then they are identified early in the cycle, typically soon after the commit. Finding the bugs closer to commit does make them much more easier to fix.
Continuous Integrations doesn’t get rid of bugs, but it does make them dramatically easier to find and remove.
There are lots of tools that provide CI capabilities. Most common ones are Jenkins from CloudBees, Travis CI, Go from ThoughtWorks, and Bamboo from Atlassian.
Continuous Delivery is the next logical step of Continuous Integration. It means that every change to the system, i.e. every commit, can be released for production at the push of a button. This means that every commit made to the workspace is a release candidate for production. This release however is still a manual process and require an explicit push of a button. This manual step may be essential because of business concerns such as slowing the rate of software deployment.
Continuous Delivery
At certain times, you may even push the software to production-like environment to obtain feedback. This allows to get a fast and automated feedback on production-readiness of your software with each commit. A very high degree of automated testing is an essential part to enable Continuous Delivery.
Continuous Delivery is achieved by building Deployment Pipelines. This is best described in Continuous Delivery book by Jez Humble (@jezhumble).
A deployment pipeline is an automated implementation of your application’s build, deploy, test, and release process.
The actual implementation of the pipeline, tools used, and processes may differ but the fundamental concept of 100% automation is the key.
What is Continuous Deployment?
Continuous Deployment is often confused with Continuous Delivery. However it is the logical conclusion of Continuous Delivery where the release to production is completely automated. This means that every commit to the workspace is automatically released to production, and thus leading to several deployments of your software during a day.
Continuous Deployment
Continuous Delivery is a basic pre-requisite for Continuous Deployment.
https://cdinsight.wordpress.com
https://www.intertech.com/Blog/devops-tutorial-part-3-artifact-management/ http://blog.sonatype.com/2009/04/what-is-a-repository/ https://www.jfrog.com/support-service/whitepapers/6-reasons-devops-use-binary-repository-manager/
Maturity Models allow a team or organization to assess its methods and process against a clearly defined benchmark. As defined in Capability Maturity Model – The term “maturity” relates to the degree of formality and optimization of processes, from ad hoc practices, to formally defined steps, to managed result metrics, to active optimization of the processes.
The model explains different stages and helps teams to improve by moving from a lower stage to a higher one. Several Continuous Delivery Maturity Models are available, such as InfoQ, UrbanCode, ThoughtWorks, Bekk, and others.
Capability Maturity Model Integration (CMMI) is defined by Software Engineering Institute at Carnegie Mellon University. CMMI-Dev particularly defines model that provides guidance for applying CMMI best practices in a development organization. It defines five maturity levels:
- Initial
- Managed
- Defined
- Quantitatively Managed
- Optimizing Each of these Continuous Delivery maturity models mentioned define their own maturity levels. For example, Base, Beginner, Intermediate, Advanced, Expert are used by InfoQ. Expert is changed to Extreme for UrbanCode. ThoughtWorks uses CMMI-Dev maturity levels but does not segregate them into different areas.
Here is another attempt to the maturity model that picks the best pieces from each of those.
- Start here
- Awesome Sysadmin
- continuous integration and continuous delivery
- DevOps Defined
- DevOps by Example: Tools, Pros and Cons of a DevOps Culture
-
Understanding DevOps: Foster a culture for building better apps faster
-
DevOps the Wall of Confusion understanding the basics of DevOps
-
The Product Managers’ Guide to Continuous Delivery and DevOps
-
31 Reference Architectures for DevOps and Continuous Delivery
35 Questions to Ask While Creating a Deployment Pipeline https://dzone.com/articles/empowering-developers-to-deploy?
The DevOps.com Application Performance Management Leadership Links Guide https://devops.com/devops-com-application-performance-management-leadership-links-guide/
- Continuous Deployment
- Automated Testing
- Release Management
- App Performance Monitoring
- Load Testing & Auto-Scale
- Availability Monitoring
- Change/Configuration Management
- Feature Flags
- Automated Environment De-Provisioning
- Self Service Environments
- Automated Recovery (Rollback & Roll-Forward)
- Hypothesis Driven Development
- Testing in Production
- Fault Injection
- Usage Monitoring/User Telemetry
- Configuration Management
- Streamlining Dev Environment Setup
- Orchestration
- Service Discovery
- Log & Error Management
- Monitoring & Alerting
- Dashboards
- Automated Deployment
- Backup & Disaster Recovery
- Security
- Scalability
- Email Service
Implementation and maintenance of internal microservices such as Jenkins, code review system, infrastructure monitor, git server, etc.
Implemented continuous integration and Continuous Delivery process using Git/SVN, Jenkins, Maven & AWS. Implemented continuous deployment pipeline using Jenkins, Chef and Shell Scripting. Implemented continuous testing pipeline using Jenkins, Selenium, Chef and Shell Scripting.
http://electric-cloud.com/resources/continuous-delivery-101/continuous-deployment/
http://electric-cloud.com/solutions/full-stack-provisioning/
http://electric-cloud.com/solutions/continuous-integration-ci-automation-and-acceleration/
http://electric-cloud.com/solutions/devops-orchestration/
http://electric-cloud.com/solutions/deployment-automation/
http://electric-cloud.com/solutions/release-management/
http://electric-cloud.com/solutions/chef-puppet-orchestration/
http://electric-cloud.com/solutions/container-orchestration/
http://electric-cloud.com/solutions/embrace-extend-jenkins/
http://electric-cloud.com/solutions/qa-lab-provisioning/
http://electric-cloud.com/solutions/compliance-and-auditing/
http://electric-cloud.com/solutions/agile/
http://electric-cloud.com/solutions/unlock-agile-bottleneck/
http://electric-cloud.com/solutions/iot-and-embedded/
Service monitoring Error tracking Performance metrics Production debugging Safety nets
- Configuration Management
- Continuous Integration
- Continuous Inspection
- Containerization
- virtualization
http://electric-cloud.com/resources/webinars/ https://www.cloudbees.com/resources/devops-radio http://electric-cloud.com/lp/continuous-discussions/
https://continuousdelivery.com/
- Docker
- Puppet
- Chef
https://devopsbootcamp.osuosl.org/index.html
https://www.quora.com/Configuration-Management-Can-you-explain-what-are-the-usecases-for-puppet-and-chef Chef-use-cases
- Ansible vs. Chef vs. Fabric vs. Puppet vs. SaltStack
- Chef is for developers, Puppet is for admins (There, that’s settled)
- Puppet versus Chef
- Puppet vs. Chef - The Battle Wages On
- Puppet vs. Chef Revisited
- Building and Securing a Modern Backend API
- Continuous Delivery of iOS Applications with Team Services
- Continuous Integration for iOS Apps with Visual Studio Team Services
- THE IMPORTANCE OF AGILE AND DEVOPS FOR END-USER EXPERIENCE
- 43 free and open-source tools that put the Ops in DevOps
- Mobile antivirus fail: Why secure DevOps is the way forward
- Demystifying Scrum for the Ops Crowd
Lesson Learned in Scaling Enterprise DevOps https://www.youtube.com/watch?v=PheuDcnWS_c
http://dtosolutions.com/devops/devops-workshops/
https://www.sonatype.com/all-day-devops-ondemand?submissionGuid=614e059d-3941-46a3-b759-fd07072b04b7
Getting Started with Secure DevOps https://devops.com/getting-started-secure-devops/
SQL Server Data Tools in your DevOps pipeline https://channel9.msdn.com/Shows/Visual-Studio-Toolbox/SQL-Server-Data-Tools-in-your-DevOps-pipeline
7 Highly Effective Continuous Delivery Principles https://devops.com/7-highly-effective-continuous-delivery-principles/
Set up custom process groups for monitoring https://www.dynatrace.com/blog/set-custom-process-groups-monitoring/
How Capital One Automates Automation Tools https://dzone.com/articles/how-capital-one-automates-automation-tools
Embedding Ownership: A DevOps Best Practice https://dzone.com/articles/embedding-ownership-a-devops-best-practice
Business impact analysis now provided with each detected problem https://www.dynatrace.com/blog/business-impact-analysis-now-provided-detected-problem/
Starting and Scaling DevOps in the Enterprise: Optimizing The Basic Deployment Pipeline https://dzone.com/articles/starting-and-scaling-devops-in-the-enterprise-opti
A/B Testing and Web Performance https://dzone.com/articles/ab-testing-and-web-performance
