Devops Tools

Cloud Computing Platforms - Fundamentally accelerates the access to compute resources to facilitate faster software development and improved application scalability.
Amazon Web Services
Pivotal Cloud Foundry
Google Cloud Platform
Microsoft Azure
Rackspace
OpenStack


Virtualization Platforms - Uses software to abstract hardware and make it possible to run multiple applications at the same for more efficient use of compute resources.
VMware
KVM
Xen
VirtualBox
Vagrant
QEMU


Containerization - Wraps software in a complete filesystem that contains everything it needs to run to enable automated deployments and more reliable software.
Docker
rkt
LXC


Linux OS Installation - Performs unattended operating system installation and configuration.
Kickstart
Cobbler
Fai


Configuration Management and Infrastructure as Code - Allows teams to declare and automate system configuration for better application manageability and IT productivity.
Puppet
Chef
Ansible
HashiCorp Terraform
AWS CloudFormation


Test and Build Systems - Facilitates continuous integration and continuous delivery by automating repeatable jobs as part of the software development process.
Solano Labs
Jenkins
Gradle


Application Deployment - Automates the process of making a new version of an application available on one or more web servers.
Capistrano


Monitoring, Alerting, and Trending - Allows digital teams to measure the impact of frequent release cycles across complex, dynamic IT environments.
New Relic
PagerDuty
VictorOps
Sensu
xMatters
BlueMedora


Logging - Provides an intuitive interface for analyzing machine-generated data for easier application-issue detection and resolution.
PaperTrail
Logstash
Loggly
Logentries
Splunk
SumoLogic


Process Supervisors - Eases the management of operating system services.
Monit
runit
Supervisor
God
Blue Pill
Upstart
systemd


Security - Helps you keep your applications safe from threats even as you release faster and adopt new technologies.
Snorby Threat Stack
Snort
Veracode
Sqreen
Sonatype
Evident.io


Collaboration and Ticketing - Allows diverse DevOps teams to break down organizational silos through better, more transparent communication.
Slack
HipChat
JIRA
ServiceNow


Orchestration - Software systems that facilitate the automated management, scaling, discovery, and/or deployment of container-based applications or workloads.
Kubernetes
Apache Mesos, DC/OS
HashiCorp Atlas
Docker Swarm
AWS Elastic Container Service



Eg: typical tools used

Configuration management:
Ansible
Chef
Puppet

Deployment:
Ansible
Jenkins

Monitoring:
Dynatrace

Version control:
Git

Test and build:Ant
Jenkins

Agile: Methodology and practices

What Is Agile?

Agile software development is based on an incremental, iterative approach. Instead of in-depth planning at the beginning of the project, Agile methodologies are open to changing requirements over time and encourages constant feedback from the end users. Cross-functional teams work on iterations of a product over a period of time, and this work is organized into a backlog that is prioritized based on business or customer value. The goal of each iteration is to produce a working product.

In Agile methodologies, leadership encourages teamwork, accountability, and face-to-face communication. Business stakeholders and developers must work together to align the product with customer needs and company goals. 

Agile refers to any process that aligns with the concepts of the Agile Manifesto. In February 2001, 17 software developers met in Utah to discuss lightweight development methods. They published the Manifesto for Agile Software Development, which covered how they found “better ways of developing software by doing it and helping others do it” and included four values and 12 principles. The Agile Manifesto is a dramatic contrast to the traditional Project Manager’s Body of Knowledge (PMBOK) guide and standards.

12 Principles of Agile Methodology

The Agile Manifesto lists 12 principles to guide teams on how to execute with agility. These are the principles:

1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
2. Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
3. Deliver working software frequently, from a couple of weeks to a couple of months, with preference to the shorter timescale.
4. Business people and developers must work together daily throughout the project.
5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
7. Working software is the primary measure of progress.
8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
9. Continuous attention to technical excellence and good design enhances agility.
10. Simplicity -- the art of maximizing the amount of work not done -- is essential.
11. The best architectures, requirements, and designs emerge from self-organizing teams.
12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly. 

The Agile Development Cycle

Here are the phases in the Agile development cycle. It’s important to note that these phases shouldn’t happen in succession; they are flexible and always evolving. Many of these phases happen in parallel.  

• Planning: Once an idea is deemed viable and feasible, the project team comes together and works to identify features. The goal of this phase is to break down the idea into smaller pieces of work (the features) then to prioritize each feature and assign it to an iteration. 
   
• Requirements analysis: This phase involves many meetings with managers, stakeholders, and users to identify business requirements. The team needs to gather information like who will use the product and how they will use it. These requirements must be quantifiable, relevant, and detailed.
   
• Design: The system and software design is prepared from the requirements identified in the previous phase. The team needs to think about what the product or solution will look like. The test team also comes up with a test strategy or plan to proceed.
   
• Implementation, coding or development: This phase is all about creating and testing features, and scheduling iterations for deployment (following the iterative and incremental development approach [IID]). The development phase starts with iteration 0, because there are no features being delivered. This iteration lays down the foundation for development, with tasks like finalizing contracts, preparing the environments, and funding.
   
• Testing: Once the code has been developed, it is tested against the requirements to make sure the product is actually solving customer needs and matching user stories. During this phase, unit testing, integration testing, system testing, and acceptance testing are done.
   
• Deployment: After testing, the product is delivered to customers for them to use. However, deployment isn’t the end of the project. Once customers start using the product, they may run into new problems that the project team will need to address.

Methodologies That Are Used to Implement Agile

Agile is a framework and there are a number of specific methods within the Agile movement. You can think of these as different flavors of Agile: 

• Extreme Programming (XP): Also known as XP, Extreme Programming is a type of software development intended to improve quality and responsiveness to evolving customer requirements. The principles of XP include feedback, assuming simplicity, and embracing change.
   
• Feature-driven development (FDD): This iterative and incremental software development process blends industry best practices into one approach. There are five basic activities in FDD: develop overall model, build feature list, plan by feature, design by feature, and build by feature.
   
• Adaptive system development (ASD): Adaptive system development represents the idea that projects should always be in a state of continuous adaptation. ASD has a cycle of three repeating series: speculate, collaborate, and learn.
   
• Dynamic Systems Development Method (DSDM): This Agile project delivery framework is used for developing software and non-IT solutions. It addresses the common failures of IT projects, like going over budget, missing deadlines, and lack of user involvement. The eight principles of DSDM are: focus on the business need, deliver on time, collaborate, never compromise quality, build incrementally from firm foundations, develop iteratively, communicate continuously and clearly, and demonstrate control. 
   
• Lean Software Development (LSD): Lean Software Development takes Lean manufacturing and Lean IT principles and applies them to software development. It can be characterized by seven principles: eliminate waste, amplify learning, decide as late as possible, deliver as fast as possible, empower the team, build integrity in, and see the whole.
   
• Kanban: Kanban, meaning “visual sign” or “card” in Japanese, is a visual framework to implement Agile. It promotes small, continuous changes to your current system. Its principles include: visualize the workflow, limit work in progress, manage and enhance the flow, make policies explicit, and continuously improve.
   
• Crystal Clear: Crystal Clear is part of the Crystal family of methodologies. It can be used with teams of six to eight developers and it focuses on the people, not processes or artifacts. Crystal Clear requires the following: frequent delivery of usable code to users, reflective improvement, and osmotic communication preferably by being co-located.
   
• Scrum: Scrum is one of the most popular ways to implement Agile. It is an iterative software model that follows a set of roles, responsibilities, and meetings that never change. Sprints, usually lasting one to two weeks, allow the team to deliver software on a regular basis

Other Practices in Agile

There are many other practices and frameworks that are related to Agile. They include:

• Agile Modeling (AM): Agile modeling is used to model and document software systems and is a supplement to other Agile methodologies like Scrum, Extreme Programming (XP), and Rational Unified Process (RUP). AM is not a complete software process on its own. It can help improve models with code, but it doesn’t include programming activities. 
   
• Rational Unified Process (RUP): Created by the Rational Software Corporation, a division of IBM, RUP is an iterative, adaptive framework for software development. According to Rational, RUP is like an online mentor that provides guidelines, templates, and examples for program development. The key aspects of RUP include a risk-driven process, use case focused development, and architecture-centric design.
   
• Lean vs Agile: Lean development focuses on eliminating and reducing waste (activities that don’t add any value). Lean development takes the principles from Lean manufacturing and applies them to software development. These principles are very similar to Agile, however Lean takes it one step further. In the development phase, you select, plan, develop, test, and deploy only one feature before you repeat the process for the next feature.
   
• Test-Driven Development (TDD): Test-driven development relies on repetitive, short development cycles. First, a developer writes an (initially failing) automated test case for a new feature and quickly adds a test with the minimum amount of code to pass that test. Then, he refactors the new code to acceptable standards. 
   
• Scaled Agile Framework (SAFe trademark logo): The Scaled Agile Framework is a very structured method to help large businesses get started with adopting Agile. SAFe is based on Lean and Agile principles and tackles tough issues in big organizations, like architecture, integration, funding, and roles at scale. SAFe has three levels: team, program, and portfolio. 
   
• Rapid Application Development (RAD): RAD’s approach to software development puts more emphasis on development than planning tasks. It follows an incremental model, where each component is developed in parallel. The phases in RAD are: business modeling, data modeling, process modeling, application generation, and testing and turnover.
   
• Empirical Control Method: With Agile software development, you can use an Empirical Control Method, which means that you make decisions based on the realities you observe in the actual project. The empirical model of process control has three parts: visibility, inspection, and adaption.

Java Web project with Maven in Eclipse

1. Install the Maven support for Eclipse (m2e)

Most Eclipse downloads include the Maven tooling already. If it is missing in your installation, you can install it via the main update of your release via Help ▸ Install New Software. The following listing contains the update site for the Neon release and an update site maintained by the m2e project.

// Neon update site
http://download.eclipse.org/releases/neon

// Update site provided by m2e project
http://download.eclipse.org/technology/m2e/releases

2. Download the Maven index

By default, the Maven tooling does not download the Maven index for the Eclipse IDE. Via the Maven index you can search for dependencies, select them and add them to your pom file. To download the index, select Windows ▸ Preferences ▸ Maven and enable the Download repository index updates on startup option.

3. Create a Java Web project in eclipse using Maven

  Step 1. Go to File > Maven Project > Next. Then maven-archetype-webapp

  Step 2 Name archetype. This will be the name of the project

   

And then press finish

Note -: If you see error “The superclass “javax.servlet.http.HttpServlet” was not found on the Java Build Path index.jsp /CrunchifyMavenTutorial/src/main/webapp” then add below maven dependency.

pom.xml

1 2 3 4 5

<dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> </dependency>

OR add Apache Tomcat to your Targeted Runtimes.

Step 3 :   Under run > maven build , type:    clean install as goal

Step 4:  Add Target Runtime and run web application.Now run on server

Getting Started With Maven

This blog guides you through initial setup and running of maven. 

Step 1:

Download Maven binary zip file from https://maven.apache.org/download.cgi

Download file : apache-maven-3.3.9-bin.zip

Step 2:

Extract folder and place at any location in your system. Lets suppose we store at

Step 3:

Set environment variable

Add JAVA_HOME and MAVEN_HOME.  And then both home location in your path system variables.

Step 4: Now open command prompt and go to workspace and then type below command.

mvn archetype:generate -DgroupId=com.vikas -DartifactId=SimpleMavenTestStart -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Project created with all pom.xml.  

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.vikas</groupId>
  <artifactId>SimpleMavenTestStart</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>NumberGenerator</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project

Step 5:  Now we can update pom.xml  as per requirement of project.

Step 6:  To generate jar file of project

type command:   mvn package

Now under target folder SimpleMavenTestStart-1.0-SNAPSHOT.jar  gets created.

Step 7: To run jar type below command

java -cp target/SimpleMavenTestStart-1.0-SNAPSHOT.jar com.vikas.App

Step 8:  Now to open same project in eclipse

type:            mvn eclipse:eclipse

Now, project is ready to be imported in eclipse, if required

Step 9: Now to deal with this project as maven project from inside eclipse

Select project and right click , go to Configure> Convert to Maven Project 

Step 10 :Now to build or verify 

Go to run as maven build> type goal as  :

clean verify or

clean install