Ken Sipe

Are you Mocking Me (with Spock)

8:30 AM MDT

Spock is a groovy based testing framework that leverages all the “best practices” of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans… and you get Spock!

There are 3 tools I use on every Java project I control… this is one of them and with good reason.

This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool. Topics include:

Unit testing
Data driven tests
Mocking and Stubbing
Partial Mocks
Spock Extensions

Flying through Cloud Native (CNCF)

10:30 AM MDT

The maturing of industry projects and tools around cloud development and administration has led to the formation of the Cloud Native Computing Foundation. This new foundation is similar to the Apache Foundation in that it provides governance over projects from incubation to maturity. These projects define the current and future standards of the cloud which is important for all devops teams to be aware of. This session is a guided at jet speed tour of each project and how it fits in the eco-system.

This session will briefly cover each of the CNCF projects will a outline of:

• what the project is
• how it works
• level of maturity
• competitive landscape

The projects covered include:

• Kubernetes
• containerd
• Prometheus
• OpenTracing
• Fluentd
• rkt
• CNI
• Jaeger
• Notary
• Envoy
• CoreDNS
• Linkerd

Java 9 Memory and GC

1:00 PM MDT

So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 9 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.

This session will look at the Java monitoring and management capabilities, which includes the ability to make VM argument changes on the fly. This session will dive into the different memory compartments and how they are used by the JVM. Final this session will explore the different GC options and how they affect response times and throughput.

This session will include new features in Java 9 to make it more container aware.

Container Friendly Java 9

2:45 PM MDT

Containers and Micro-service are like peanut butter and jelly, they just go together. However do you know how resources are managed in a container and how that affects your application. This session will dive into how Java is affected living under control groups.

This session will review containers, the underlying technology to containers along with different container runtimes such as Docker. We will look at the anatomy of a container including control groups (cgroups) and namespaces. This session will conclude with the challenges of running the JRE in a container and the impact that has on the efficiency of the process at scale.

This session will include container friendly changes to Java 9 around memory and ergonomics. It will also provide advice on how to get consistent CPU share.

Kubernetes Deep Dive

4:30 PM MDT

In the container orchestration space, one of the top contenders is Kubernetes (K8S). This session will go into detail of each component in Kubernetes along with how to use it. Anyone attending this session should be able to easy get stated with K8S and have an understanding of what they would need to do to their application to enable it to be K8S friendly.

This session will dive into different applications (stateful/stateless, data-focused/micro-service focused) and how they are managed with the different components of kubernetes:

• kube-apiserver
• etcd
• kube-controller-manager
• kube-scheduler
• kubelet
• kube-proxy
• pods
• container resource monitor
• UI

To 99.99 and Beyond

8:30 PM MDT

When architecting a critical system the Availability of CAP theorem becomes the most important element. Architecture measures availability in 9s with 99.99% equating less than 1 hour of unplanned downtime. This session will focus on what it takes to get there.

After establishing high availability expectations and measurements, this session will dive into what it takes to establish the highest scale possible. It includes a look at infrastructure needs with a separation between capacity and scale. A look a service discovery with pro and cons of service to service dependencies. We look at infrastructure necessary such as health checks and monitoring. The session will include a look at different layers of fault domains including cross region.