DevOps

Continuous Integration with Puppet and OpenShift

Learn how to deploy Docker images on OpenShift 3, running in Red Hat's Container Development Kit, with Red Hat Developer Studio 10 The Microservices Architecture tutorial is available at https://htmlpreview.github.io/?https://github.com/redhat-helloworld-msa/helloworld-msa/blob/master/readme.html Learn more about Red Hat Developer Studio, Docker and OpenShift 3 support in Eclipse from http://tools.jboss.org/

Assuming you are comfortable with Docker, this demo quickly walks through some of the super powers gained by running a Docker container on Kubernetes with OpenShift. Slides at http://bit.ly/kube4docker Downloads at http://developers.redhat.com/products/cdk/overview/

The myth of Java EE as a cumbersome platform is easily dispelled in this session, which aims to create a working application, from a blank repository to a live cloud deployment, in real time. It: Covers tools that bootstrap project creation, freeing you from mucking around with Maven POM boilerplate Generates a domain model and reverse-engineers JPA entities from it Automatically creates the scaffolding for tests that run in a real Java EE container, launched from the IDE Pushes it all to production on a public site Using a variety of projects from the JBoss Community adhering to and building upon open standards, this presentation can create real enterprise apps in the time it takes other sessions to click through some slides. Let's get building! Presenter: Andrew Rubinger Bio: Andrew Rubinger is an advocate for and speaker on Testable Enterprise Java development, author of upcoming "Continuous Enterprise Development in Java" and "Enterprise JavaBeans 3.1" from O'Reilly Media. JBoss Core Developer and Technical Lead of the ShrinkWrap project. Proudly employed by JBoss / Red Hat.

A lot of functionality necessary for running in a microservices architecture have been built into Kubernetes; why would you re-invent the wheel with lots of complicated client-side libraries? Have you ever asked why you should use containers and what are the benefits for your application? This talk will present a microservices application that have been built using different Java platforms: WildFly Swarm and Eclipse Vert.x. Then we will deploy this application in a Kubernetes cluster to present the advantages of containers for MSA (Microservices Architectures) and DevOps. The attendees will learn how to create, edit, build, deploy Java Microservices, and also how to perform service discovery, rolling updates, persistent volumes and much more. Finally we will fix a bug and see how a CI/CD Pipeline automates the process and reduces the deployment time.

This panel will bring together developers that understand the benefits of containers technologies, to clarify their importance, their problems, and how to apply to real world projects.

With microservices, polyglot, and DevOps on the rise, where are we at with testing? Does it bring more complexity and make our testing effort harder? Or maybe, on the contrary, it actually helps us write better tests more easily? This session explores not only how we can do our testing in this new world but also how the new world can help us test better. Meet Arquillian Cube and Q. The presentation takes a close look at topics ranging from polyglot services and orchestrated microservices to system scale testing. All are within reach. And with full control, let’s add a dash of chaos!

Yes, Docker is great. We are all very aware of that, but now it’s time to take the next step: wrapping it all and deploying to a production environment. For this scenario, we need something more. For that “more,” we have Kubernetes by Google, a container platform based on the same technology used to deploy billions of containers per month on Google’s infrastructure. Ready to leverage your Docker skills and package your current Java app (WAR, EAR, or JAR)? Come to this session to see how your current Docker skill set can be easily mapped to Kubernetes concepts and commands. And get ready to deploy your containers in production.

Everyone's heard about Docker and how it's going to solve all of our problems, or not. In this session, we'll walk you through using Docker and discuss why using a scheduler and orchestration system is important. Then we'll dive into an actual usage of the container application platform, OpenShift Enterprise 3 by Red Hat, to show how it makes both Docker and Kubernetes accessible to the average human being. We'll keep the slides to a minimum and instead focus on live demo/coding/deployments. After deploying several containers, we'll turn up the heat by showcasing scaling and moving on to deployment strategies including blue/green.

Kubernetes is a powerful, open source, container orchestration and cluster management tool from Google. It drew upon all the lessons learned from a near-decade of using containers at Google. In this session, we'll look beyond container orchestration with Kubernetes and take a deep dive into more advanced features such as autoscaling. But its most powerful feature is its versatile REST API, which you can use to tailor Kubernetes to your needs. In addition to the out-of-the-box Kubernetes Autoscaler, we'll look at: - How to access the Kubernetes API securely - The different Kubernetes resources such as Pod, Replication Controller, Service, etc. - How to update/manage your entire cluster using the API We'll use the techniques and the REST API to demonstrate how to cluster Infinispan, an in-memory data grid, in Kubernetes, and autoscale Infinispan using custom metrics.

When you hear the term "MBaaS," or "Red Hat Mobile," there is usually a lot of discussion about powerful scaling, back-end integrations, hosting options, containerization, etc. However, we can't forget what that "M" stands for, and why the platforms exist in the first place, which is to develop and deliver top-notch mobile applications to your users. In this session, we'll review what makes all of this possible—client SDKs, hybrid solutions like Cordova, and Xamarin, and our own Build Farm and Unified Push server. Not stopping there, our AppForms support makes it a snap to tie in back-end systems all the way to your app. And this is all backed by various templates, guides, and new open source resources that will help you get started and join the fun.

Using Docker for building and packaging small discrete microservices, and Kubernetes to ensure they stay running and gaining OOTB service discovery, significantly reduces the challenges of having a consistent way to build, package, and run applications. Then, there's how to develop, test, promote, release, support, and improve our container-based architectures, taking an idea from inception to repeatable releasing in a live environment. In this session, we'll look at how fabric8, which runs on top of OpenShift 3 by Red Hat and Kubernetes, uses Docker and Jenkins workflow for pipeline orchestration to provide an extensible OOTB CD solution. Fabric8 significantly simplifies the creation of new projects with a one-click setup and the wiring-together of tooling such and version control systems, artifact repositories, and release pipelines. With human approval, automated integration testing, ChatOps, environment + pipeline visualisation, commit traceability, and a developer experience that helps teams deliver value faster, we'll see how the strength of the open source community works together to provide a consistent approach to building and releasing software for new, cloud-based microservices.

Are you ready to innovate with cloud-native app development? Are you ready to accelerate business agility with continuous delivery (CD)? Well, now you can easily do both using CloudBees Jenkins Platform within OpenShift Dedicated by Red Hat. In this session, you'll learn how to seamlessly use this CD solution to fully automate your application development, test, and delivery life cycle. Using the CloudBees platform to automate your CD pipelines allows your developers to focus on what they do best—innovating. Combine that with the elasticity and scale of the Docker-based OpenShift Dedicated environment, and you'll remove many of the obstacles to business growth. Come see the future of digital innovation.

Aslak Knutsen & Bartosz Majsak: The production system has been targeted by troublesome random failures over a long period of time, and countless hours of debugging has yielded no valuable results. We're close to throwing in the towel. An army of Chaos Monkeys has been deployed in an attempt to force the issue, but no solution is in sight. We need to take back control. It's time to meet the Assertable Chaos Monkey, Arquillian Cube Q. Arquilian Cube Q is an extension that gives you full control over a production-like system right from the comfort of your IDE. In this session, we'll explore some of the things you can do when you have control over the whole system. We'll validate scalability and connectivity, assert the failure state, enforce service responses, and more.

This presentation will take developers behind the scenes of the Keynote Demo to showcase how designers and a developers work together to achieve outstanding results. In this presentation, we'll identify the gap between designers and developers, and walk you through an actual example of how to build bridges that increase trust in your products. You'll learn about: - UX basics - Design within open source communities - Understanding the problems between developers and designers - The advantages (and disadvantages) of working with a designer - Coping with common pitfalls and false assumptions - Specific CSS and JS techniques used during the Keynote demo visualization You'll leave knowing that UX goes beyond the UI, with a better understanding of why working with a designer is important, and how to work together successfully.

Delivering an app or service fast and frequently to production isn't the same as delivering the app or service fast and frequently to its intended users. Before an app is actually 'live' it has to run the gauntlet of production deployment that stands between it and real, live users. While DevOps has helped organizations make huge strides toward continuous delivery in dev and test environments, the production environment remains a very real obstacle in realizing continuous deployment. The biggest hurdle in that obstacle course is a narrow definition of DevOps that fails to include a broad set of technologies and tools outside the Dev and Ops domain. In this session we'll explore the underlying elements of a comprehensive DevOps approach (SDN, CD/CI, and Agile) and how they mix, match, and combine to enable the operational transformation DevOps promises to achieve the ultimate goal of IT agility: continuous deployment.

As developers, we're constantly trying to improve the way we build systems and work as a team. Agile, DevOps, and Lean are all frameworks to help us be better developers and write better systems, but it still seems to be a constant struggle. Commander Chris Hadfield is a bona fide astronaut, test pilot, and rocket scientist, and he commanded the International Space Station for 3 months, making waves back on earth with his cover of Bowie’s Space Oddity. On returning, he wrote a book about everything he learned on his journey to becoming an astronaut. You’d be surprised by how much of it applies to application development. Application development should be easy—it ain't rocket science. In this session, you'll learn: - How Russia represents DevOps and Lean development, while America represents the waterfall method - How to create robust systems by thinking, “What could kill me next?” - How astronauts make amazing teams, and how to apply that in our own environments.

We know how to code. We know how to test. But all too often, we’re disjointed in bringing our applications to life in production. In this practical session based on the lessons showcased in the Summit middleware keynote, we’ll walk through both the concepts and software that lets developers push to production with confidence. Join the Developer Experience Engineering team as we give you a chance to quickly get started with a full deployment pipeline for new applications, focusing on: * Testability as a first-class citizen * Using the cloud as an extension of your local development environment * Reviewing your changes in isolation in a production-like environment * A smooth merge process to get your changes upstream * Getting your stuff live, reliably and efficiently See how we brought everything to life on the big stage during the middleware keynote and take some lessons home to try yourself.

Scale changes everything. What once was quite adequate for enterprise messaging can't scale to support "Internet of Things". We need new protocols, patterns and architectures to support this new world. This session will start with basic introduction to the concept of Internet of Things. Next it will discuss general technical challenges involved with the concept and explain why it is becoming mainstream now. Now we’re ready to start talking about solutions. We will introduce some messaging patterns (like telemetry and command/control) and protocols (such as MQTT and AMQP) used in these scenarios. Finally we will see how Apache ActiveMQ is gearing up for this race. We will show tips for horizontal and vertical scaling of the broker, related projects that can help with deployments and what the future development road map looks like.

Red Hat's Ju Lim and Serena Doyle of the User Experience Design Team walk us through the dashboard for Kubernetes clusters and OpenShift V3 in CloudForms

Overview of Shippable's CI/CD integration for OpenShift 3 with a technical deep dive demo, followed by Q/A with OpenShift Commons Participants.

Docker is awesome, but how to use it well when doing Java development ? In this talk you will get a quick introduction on how to use Docker effectively, especially for Java EE development. We will show how the recent release of Eclipse Mars supports Docker to make it even more integrated into your day-to-day work from within your IDE. In particular, you'll see how you can pull and run an image for a database, build a custom image for an application server, run it and deploy a JavaEE application using data volume, exposed ports and container links. And more !

Fabric8 is an integration and management platform adding to the Java developer's perspective of Kubernetes and OpenShift. It consists of multiple parts. Fabric8 tooling helps tremendously in deploying Java applications on Kubernetes and OpenShift by creating all the complex deployment descriptors directly from a Java build. In addition, fabric8 contains a rich set of DevOps Microservices which provides a flexible and automatedsetup for a Continous Integration and Delivery pipeline on a per project basis. It also includes an integration-Platform-as-a-Service (iPaaS) centered around Camel and ActiveMQ with rich visualisations and one click installations. But the queen of fabric8 is its web console which allows for a rich user experience for managing Kubernetes services, pods and more. With this in place even complex setups can be easily managed. This talk provides an overview over all these components and shows how the pieces fit together.

(Part 1)Containers are enabling developers to package their applications in new ways that are portable and work consistently everywhere: on your machine, in production, in your data center, and in the cloud. And Docker has become the de facto standard for those portable containers in the cloud. This lab offers developers an intro-level hands-on session with Docker, from installation to exploring Docker Hub, to crafting their own images, to adding Java apps and running custom containers. This is a BYOL (bring your own laptop) session, so bring your Windows, OS X, or Linux laptop and be ready to dig into a tool that promises to be at the forefront of our industry for some time to come.

Developer Interview (#DI16) with Veer (@VeerMuchandi) Docker, OpenShift Enterprise v3, Kubernetes