DevOps

Open SOurce COurse

https://github.com/DevOpsBasicSetup/Phase-1-Discussions

overview

In many ways, culture can be one of the hardest things to change, but it can be done. To that end, here are ten simple steps any organisation can take to manage cultural change when implementing DevOps:

Make sure the very highest levels of your organisation are ready to commit to the DevOps philosophy. DevOps will not succeed if introduced from the bottom-up. There are too many processes that need to change that will require sign-off from management.
At the same time, the DevOps team needs a free hand in defining their roles and responsibilities. At first, they may define their roles in familiar ways based on old patterns, but as they get more experienced in the ways of DevOps, they will naturally evolve.
Bring in an external coach to educate DevOps team. They will help the team demolish walls and become a single team. Coaches have the experience to know what is and isn’t possible and how best to move forward. Do not make one of your line managers a coach, as there may too much of a bias/baggage that they may bring to the team.
Even if you start with just a pilot team make sure you start to educate the rest of the teams. Communicate the benefits and the new processes. The pilot team will need help from time to time and if other teams understand the transformation they are more likely to provide that help.
Give your DevOps team the freedom to fail. Hold them accountable for their own actions. The more they fail the more resilient they will be. If they don’t have the responsibility, they won’t take ownership. This means eliminating management-run post-mortems where the team becomes defensive and risk-averse. Your mantra should be “fail fast.”
Help the DevOps team to break down their silos. It takes a while to break the silo mentality. Help them understand that it doesn’t matter if you are dev, ops or security, your goal is still to match speed with quality.
Co-locate the teams as much as possible. When this happens, the team members will help each other. It will help them to mature and function as one team much quicker. Train the teams in automating their process.
Leaders should talk to the teams often to see what’s required for success – communication has to go both ways. This should be a collaboration, otherwise simple issues become roadblocks.
DevOps is by definition a lean, flat organisation. Don’t expect or require all the good ideas to come from leadership. Good ideas can come from anywhere, from anyone, at any time.
The upper echelons of the organisation should lead by example. Break down silos, collaborate, speed up decision-making processes. All of this can inspire your DevOps team in what can be a difficult transition.

https://www.slideshare.net/gauravslide/transform-agile-development-with-practical-devops-86846081

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 Tools

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

Benefits

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.

SPECIALIZATIONS

Infrastructure: Amazon Web Services, VMware, RackSpace, Microsoft Azure, KVM, Heroku, Amazon OpsWorks, Amazon ElasticBeanstalk, Docker, Vagrant
Web / Application Architecture / Site Performance / Load Balancing: Apache, NGINX, JBoss, Apache Tomcat, Rails, Node.js, DJango, PHP, Amazon CloudFront, Akamai, Amazon AutoScaling, Varnish Software, Memcached, Redis, Amazon ElastiCache, Red Hat Cluster Suite, F5 LTM (Local Traffic Manager) & GTM (Global Traffic Manager), Amazon Elastic Load Balancer, HAProxy
Authentication, Authorization, and Access Control OpenLDAP: RSA Authentication, Radius Authentication, MFA (Multi-Factor Authentication)/Google Authenticator, Centrify/Powerbroker, SAML, OAuth
Environment Build and Deployment: Packer, PXE, Foreman, Red Hat Kickstart, Spacewalk, RedHat Satellite Service, Mrepo, Pulp
Orchestration / Service Discovery: Consul, Registrator, Consul Template, Shipyard, CloudFormation, Terraform
Configuration Management / Automation: Puppet, Chef, SaltStack, Ansible, Beaker, TestKitchen, ServerSpec, Berkshelf, r10k
Big Data Operations: Apache Hadoop, Cloudera, MapR, Hortonworks, Kafka, Storm, Oozie, Sqoop, Pig
Operational Visibility (Service Health Monitoring, Capacity Planning, and Reporting): Elasticsearch, Logstash, Kibana, Splunk, Graphite, Grafana, Cacti, SNMP, Diamond, CollectD, NRPE, Nagios, Sensu, CloudWatch
Release Management: GIT, SVN, Stash, GitLab, GitHub, BitBucket, Docker Registry Hub / Private Registry, Jenkins, Bamboo, TravisCI
Message Queuing: RabbitMQ, ZeroMQ, ActiveMQ, Amazon SQS,
Storage: NFS File Server, iSCSI, Fiber Channel, NAS / SAN, Netapp, 3par, EMC, Multipath / MPIO, device-mapper, PowerPath
Security: Host based Firewalls (Iptables), SSL VPN (OpenVPN), IPSEC VPN (OpenSwan, LibraSwan), Amazon VPC, IAM, Security Groups & ACLs, SELinux, Auditing and hardening Linux servers
ITIL Service Operations (Incident, Problem, and Event Management): Design and implement change control solutions, Design and implement disaster recovery solutions, Design and implement business continuity solutions, Root-cause analysis investigation, Linux Kernel performance troubleshooting and tuning, Application performance troubleshooting and tuning
Backup and Recovery: Tivoli – TSM, HP DataProtector, Bacula, NetBackup, BackupExec, Rsync-based solutions

Continuous.*

For those of you not up to speed with this industry trend, here is a brief overview of this new terminology:

Continuous integration: The practice of merging all developer working copies to a shared mainline several times a day
Continuous delivery: The evolution of continuous integration by always being able to put a product into production
Continuous deployment: Taking continuous integration and continuous delivery for automatic deployment to production
Continuous development: The umbrella term of continuous integration, continuous delivery, and continuous deployment
Continuous testing: The process of executing automated tests as part of the software delivery pipeline in order to gain feedback on business risks with a software release candidate as rapidly as possible
Test automation: Designed to produce a set of pass/fail data points correlated to user stories and application requirements
DevOps: The software engineering practice that aims at unifying software development (Dev) and software operation (Ops)

DevOps Tools

https://xebialabs.com/periodic-table-of-devops-tools/

DevOps culture

https://dzone.com/articles/real-world-problems-solved-by-devops https://techbeacon.com/30-common-challenges-devops-how-resolve-them

Typical DevOps roles

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

What problems are solved by DevOps

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.
1. 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.

What is Continuous Integration?

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.

What is Continuous Delivery?

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.

For Ideas

https://cdinsight.wordpress.com

Artifact Repository

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/

Continuous Delivery Maturity Model

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

DevOps Transformation Services

Painless, End-To-End Cloud enabled Application Life Cycle Management
Integrated Cloud Management and Orchestration
DevOps as a Service
DevOps Automation
Automated Provisioning
Deployment Automation
Centralized Visibility
Service Visualization
Hybrid Process Framework
Continuous Integration & Continuous Deployment in highly agile environment
Automated Reporting and Dashboards
Infrastructure Management and Monitoring
Cloud Strategizing
Team Assessment
Security Management
Configuration Management Chef Assessment, Architecture & Consulting Automation Architecture Design Automated testing Chef Advance Training Managed DevOps & Chef implementation services Continuous Integration & Continuous delivery adoption

• Build Automation • Configuration Management • Continuous Delivery/Rapid Deploy • Functional Testing/Unit Testing/Test Driven Development • Monitoring/Alerting • Packages/Containers/Virtualization • Release Coordination/Orchestration

Continuous Release and Deployment

• Technology selection and validation • Deployment design • Deployment automation • Configuration and release management

Continuous Testing

• UI and integration test automation • Performance testing • Service virtualization • Test optimization

Continuous Monitoring

• Infrastructure monitoring automation • Software Development Auditing • Service health dashboards delivery • APM tools integration

Continuous Feedback and Optimization

• Service request and change management • Performance tuning • Incident tracking system & analysis tool development • High-availability & redundancy planning

DevOps Orchestration Services

Dev & Deploy Work Stream Automation and Visualization
Software Delivery Process Automation
Visual Monitoring of Development & Deployment Pipelines and Work Streams
Centralized Visibility, Governance and Control

https://msystechnologies.com/wp-content/uploads/2017/08/deveops-img.png

Continuous Integration and Delivery Process

https://msystechnologies.com/wp-content/uploads/2017/08/deve-automative.png

http://www.karyatech.com/images/devops-img.png

OUR OFFERINGS

Infrastructure Management

Automated Provisioning
Bringing up Servers in Deploy State (SCR)
Server State Mismatch Elimination
Server Scaling up

Code Inspection & Continuous Integration

Well-tested Code
Verified Artifacts Ready for Deployment
Improved Code Quality
High quality Build and Code Reports

Environment Management

Configuration Mismatch Elimination
Automated, Error-Free, Faster Configuration Deployment
Single Tool Management
Activity Reports Configuration

Deployment Automation & Orchestration

Automated, Error-Free, and Faster Deployment
Single-Tool Deployment
Single Click or Continuous Deployment
Deployment Metrics

http://www.nexiilabs.com/img/devops/devops-tools.jpg

https://image.slidesharecdn.com/buildingadevopsorganization-150825132107-lva1-app6892/95/building-a-devops-organization-18-638.jpg

https://image.slidesharecdn.com/buildingadevopsorganization-150825132107-lva1-app6892/95/building-a-devops-organization-21-638.jpg

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

https://www.xenonstack.com/blog/static/public/uploads/featured/Data-Ingestion-Using-Apache-Nifi-For-Building-Data-Lakes-Twitter-Data.jpg

https://image.slidesharecdn.com/devopsonaws-acceleratingsoftwaredelivery-awssummitsg2017-170428085530/95/dev-ops-on-aws-accelerating-software-delivery-awssummit-sg-2017-10-638.jpg?cb=1493369876

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

Basic

PERIODIC TABLE OF DEVOPS TOOLS

PERIODIC TABLE OF DEVOPS TOOLS

Image Speaks

Rams infographic

Containers

Getting to Know Containers

DevOps

URL

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/

DevOps

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

DevOps Concepts

Configuration Management
Streamlining Dev Environment Setup
Orchestration
Service Discovery
Log & Error Management
Monitoring & Alerting
Dashboards
Automated Deployment
Backup & Disaster Recovery
Security
Scalability
Email Service

DevOps Values

DevOps Principles

DevOps Methods

DevOps Practices

DevOps Tools

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/

DevOps solutions

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