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.
- CI Framework - Jenkins, Bamboo, Hudson, TeamCity
- Build automation - Maven, Gradle, Ant
- Deploy - CircleCi
- Issue and project tracking - JIRA, CA Agile Central, Team Foundation Server, HPE Agile Manager
- Continuous delivery - Chef, Puppet
- Test Management - QMetry Test Manager, HPE Quality Center Enterprise, ApTest
- Test Automation - QMetry Automation Studio, Selenium, Appium
- Repository management - Artifactory, Docker
- Code coverage - JaCoCo, Atlassian Clover, SonarQube, Cobertura
- Behavior Driven Development - jbehave, Cucumber
- Application performance monitoring - AppDynamics
- Application security testing - HPE Fortify
- Cloud management - Open Stack
- Mobile Device clouds - Perfecto, Sauce Labs
- Monitoring - Dynatrace, Nagios, Monit
- Version control - Git
- Config - Consul.io
- Feature Flags & Lifecycle Management - LaunchDarkly
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.
https://image.slidesharecdn.com/jenkins2-150728163959-lva1-app6892/95/continuous-integration-with-jenkins-and-git-7-638.jpg?cb=1438101733 https://www.xenonstack.com/images/DevOps.png
Our DevOps Professional Services include:
- Single Click Deployments
- Continuous Integration and Continuous Deployment
- Proper Infrastructure Security
- Automated Rollouts & Rollbacks
- Automated Security Alerts
- Supports Microservices & Serverless Computing - Docker and Kubernetes
- Easy Code Management & Code Reviews
- Deploy On-Premises, Public or Hybrid Cloud
https://www.xenonstack.com/images/devops-tools.png https://www.xenonstack.com/blog/static/public/uploads/media/nexastack-the-ultimate-devops-platform.png
- Source Code Management (SCM) System
- GitHub
-
Build and Continuous Integration(CI) Reduce Integration Issues Improve Code Quality Improve Communication and Collaboration between Team Members Faster Releases Less Bugs
-
Building tools
-
Testing JUnit: JUnit is a simple framework to write repeatable tests. Mocha: Mocha is a simple, flexible, fun JavaScript test framework for Node.js.
-
Artifacts Management
-
Configuration Management Ansible, Chef and Puppet
-
Deployment
-
Orchestration Software systems that facilitate the automated management, scaling, discovery, and/or deployment of container-based applications or workloads.
- Kubernetes: Kubernetes is an orchestration system for Docker containers. It handles scheduling and manages workloads based on user-defined parameters.
- Docker Swarm: Docker Swarm provides native clustering functionality for Docker containers, which lets you turn a group of Docker engines into a single, virtual Docker engine.
- Monitoring
The end goal for your monitoring is to consolidate tools, reduce the total cost of ownership, and automate the configuration via machine learning.
-
Collaboration & Notification Rocket Chat: Rocket Chat is an open-source messaging app built with Meteor. It supports video conferencing, file sharing, voice messages, has a fully-featured API, and more. Rocket Chat is great for those who prefer to have full control over their communications. Slack: Slack is basically a messaging app on steroids. It's meant for teams and workplaces can be used across multiple devices and platforms, and is equipped with robust features that allow you to not only chat one-on-one with associates but also in groups. You're able to upload and share files with them too, as well as integrate with other apps and services, such as Skype for video calls, and you can granularly control almost every setting, including the ability to create custom emoji.
-
Bug Management System Bugs - Whether they be in the code or in the usability of the program, can be debilitating to any project, potentially causing the entire initiative to fail.
-
Collaborative Documentation System It includes: Wiki basics Using Media Wiki, Confluence etc. Documenting DevOps Projects. Organizing Documents on a Wiki-Based System for the past DevOps Projects.
-
Security
Artifacts Management
Now that your build pipeline consistently versions your Maven project, you need a place to store your artifacts which are being produced at the end of this pipeline. These artifacts need to be stored much the same way your source code is stored in your SCM.
This ensures access to previously released versions of your product. An Artifact Repository is designed to store your war/jar/ear/etc, and distribute it to fellow developers via Maven, Ivy, or the like, share your artifact with you deployment tools, and generally ensure an immutable history of your released products.
Using a Standard Artifacts Management System such as Artifactory
Caching Third-Party Tools
http://linoxide.com/images/devops-tools-cheatsheet-infographics-700x900.png https://cdn2.hubspot.net/hubfs/208250/social-suggested-images/DevOps-Infographic-v1.4%20690x690-1.png
- 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/
https://github.com/ciandcd/awesome-ciandcd
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
