Tech Tutorials

Dropwizard Introduction

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 16 Jan 2018 02:45:00 +0000

Webinar: Up and Running with Spring Boot in NetBeans IDE

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 28 May 2016 22:57:00 +0000

NetBeans IDE is the official IDE of the Java platform. Focused on rapid out-of-the-box development of all kinds of Java applications, NetBeans is comprehensive and easy to use. In particular, its free and open source tooling for end-to-end development is much admired.

Over recent years, many developers have added NetBeans to their toolbox because of its intuitive and powerful integration with Maven and Gradle. During this session you will see how NetBeans is well suited for setting up and developing applications that make use of Spring Boot.

You will also learn about the many new features that have been added in NetBeans IDE 8.0 and 8.1, helping you working quickly and effectively with Java and Maven in the context of Spring Boot. By the end of this session, you’ll have a better grasp of Spring Boot, as well as a thorough understanding of the range of features that NetBeans provides for working with it!

Spring Flo for Spring Cloud Data Flow1.0.0M3

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 28 May 2016 22:51:00 +0000

Building and Tuning High Performance Java Platforms

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Wed, 30 Dec 2015 16:33:00 +0000

This session will cover various GC tuning techniques and how to best build platform engineered systems; in particular the focus will be on tuning large scale JVM deployments. It is true that half of the world's Java applications have 2.x more hardware provisioned than what they really need, and 90% of these applications miss their SLA. In this session we showcase why this is the case, and demonstrate sizing techniques on how to platform engineer such systems without the need for over-provisioning and hence meeting SLA in a more feasible way. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs. We will look at various Java platform scales, some holding a few large JVMs of 90GB heap space, while other platforms are of thousands of JVM instances of less than 4GB heap space on each. We will also take a close look at an example XYZCars.com where a microservices approach was designed and deployed, we will talk through how to more correctly deploy microservices without out causing fragmentation of scale, and hence without impeding performance. In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 360GB, using the GC tuning recipes that were gained over the past 15 years of GC tuning engagements. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own.

The session summarizes the techniques and the necessary JVM options needed to accomplish these complex tuning tasks, in addition to various virtualization best practices when dealing with such large Java systems. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory and CPU consumption.

Source: https://www.youtube.com/watch?v=IGS-rqSjmFk

Modern Java Component Design with Spring Framework 4.2

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 07:18:00 +0000

Spring's programming and configuration model has a strong design philosophy with respect to application components and configuration artifacts. Spring's annotation-based component story is fine-tuned for source code readability as well as consistency across an entire application's codebase. This session presents selected Spring Framework 4 component model highlights, with a focus on the upcoming Spring Framework 4.2 and a selection of Java 8 enabled features, illustrated with many code examples and noteworthy design considerations.

Getting Started with Spring Cloud

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 07:13:00 +0000

Spring Cloud 1.0 is here! It offers a powerful way to create and consume microservices. As you introduce new services, you introduce integration problems: services can be shaky, they can disappear and - as they're often exposed over HTTP - they require a bit more footwork than in-process method invocations. In this webinar, we'll focus specifically on how Spring Cloud integrates service registration (e.g. Eureka), declarative REST clients (with Netflix's Feign), reactive programming and the circuit breaker pattern with Hystrix to support easy, robust service-to-service invocations, and messaging microservices with Spring Cloud Stream. This is a deep dive on how to make connect and consume microservices, and is a natural next step after the introduction to building microservices with Spring Boot.

Lattice: A Cloud-Native Platform for Your Spring Applications

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 07:07:00 +0000

Lattice is a cloud-native application platform that enables you to run your applications in containers like Docker, on your local machine via Vagrant. Lattice includes features like:

Cluster scheduling
HTTP load balancing
Log aggregation
Health management

Lattice does this by packaging a subset of the components found in the Cloud Foundry elastic runtime. The result is an open, single-tenant environment suitable for rapid application development, similar to Kubernetes and Mesos Applications developed using Lattice should migrate unchanged to full Cloud Foundry deployments.

Lattice can be used by Spring developers to spin up powerful micro-cloud environments on their desktops, and can be useful for developing and testing cloud-native application architectures. Lattice already has deep integration with Spring Cloud and Spring XD, and you’ll have the opportunity to see deep dives into both at this year’s SpringOne 2GX. This session will introduce the basics:

Installing Lattice
Lattice’s Architecture
How Lattice Differs from Cloud Foundry
How to Package and Run Your Spring Apps on Lattice

Developer Experience with Spring Cloud

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 07:04:00 +0000

12 Factor, or Cloud Native Apps for Spring Developers

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 06:59:00 +0000

The third platform, characterized by a fluid infrastructure where virtualized servers come into and out of existence, and workloads are constantly being moved about and scaled up and down to meet variable demand, calls for new design patterns, processes and even culture. One of the most well known descriptions of these new paradigms is the Twelve Factor App (12factor.net), which describes elements of cloud native applications. Many of these needs are squarely met through the Spring Framework, others require support from other systems. In this session we will examine each of the twelve factors and present how Spring, and platforms such as Cloud Foundry satisfy them, and in some cases we’ll even suggest that responsibility should shift from Spring to platforms. At the conclusion you will understand what is needed for cloud-native applications, why and how to deliver on those requirements.

Spring Boot for DevOps

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 06:58:00 +0000

So you've decided to go cloud native. You've got a number of microservices that your company builds and runs. They interact with each other in various ways. You've got testing and staging and production environments that may have taken a lot of effort to get right. How does an individual developer work on just one of those services without stomping on other developers using a shared environment? In this session we will explore a range of options for development, starting with deploying everything locally, through stubbing, to local development solution that allows a developer to run their service in their IDE and have the whole system interact on their local machine!

Spring Boot Micro-services, Containers, and Kubernetes

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 27 Dec 2015 06:54:00 +0000

This session is to learn how to create a Java-based microservice using Spring Boot, containerize it using Maven plugins, and subsequently deploy a fleet of microservices and dependent components such as Redis using Kubernetes. Spring Boot makes creating microservices fast and easy - when it comes to running a single instance. Like most Java application, the harder part is usually the clustering and fail-over configurations. First, we'll go over how get started with Spring Boot, and, subsequently, using Maven plugins to generate and create Docker images during the build process. Next, we'll go over some basic architecture and configurations, such as: - Configuring Spring Session - Using Redis as the session store - Testing the configuration locally with container linking - Tips and tricks for faster startup (/dev/./urandom is your friend) Finally, with the images, we'll deploy the microservice into Kubernetes: - Defining pods and services - Linking microservices to Redis using Kubernetes - Perform rolling upgrades of the application - Canary new versions of the microservices into the fleet Best part - we can visualize all of these activities happening in Kubernetes.

Securing Microservices with Spring Cloud Security

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 07 Nov 2015 13:49:00 +0000

This talk will walk through the authentication and authorization scenarios that you may encounter once you start building out microservices. We'll go over OAuth2, OpenID Connect, and how to leverage those standards with Spring Cloud Security, so you can build out secure services that can be easily consumed by both Spring and non-Spring clients.

A How to Guide to Security in the PAAS Cloud

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 07 Nov 2015 13:42:00 +0000

Most developers still deal with application security issues in isolation, without understanding the security of the ""full stack"". As a result, security is sometimes inconsistent, and can be seen as a barrier to moving applications to the cloud. The session will examine the security of a typical Java Web application in an enterprise deployment. We will then look at what needs to change when that secure Java application is “forklifted” into Cloud Foundry. Finally, we will look at the benefits of adopting cloud native security protocols, such as OAuth2 and SAML2. The journey will cover 5 common application security architecture patterns taken from real world customer problems. We will compare how the security integration patterns differ between a standalone application and a cloud native application. From legacy enterprise identity management integration to security for microservices, this technical session includes practical, hands-on guidance to properly implementing authentication, authorization, and confidentiality controls using Spring and Cloud Foundry. We have all heard of the idea of the “Full Stack” developer — someone who can understand the application up and down the whole stack. The goal of this session is to describe the full security stack and show how it differs between standalone deployments and a PAAS deployment.

Spring Cloud *: Exploring Alternative Spring Cloud Implementations

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 07 Nov 2015 13:33:00 +0000

In this session we will discuss the Spring Cloud abstractions and interfaces that an implementation might choose to implement: DiscoveryClient, LoadBalancerClient, Configuration and Bus. We will compare and contrast some target technologies and discus the tradeoffs and nuances of each, such as: netflix, consul, etcd, zookeeper and lattice. We will then show and demonstrate Spring Cloud implementations of those technologies.

Flo for Spring XD: Composed Batch Job Orchestration

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 07 Nov 2015 13:29:00 +0000

Flo for Batch pipeline builds upon the newly supported Batch DSL in Spring XD that can be used to create composite batch workflows involving sequential, parallel or even the combination of both jobs.

Source : https://www.youtube.com/watch?v=kr_79McGjHY

Smarter Service-to-Service Invocations with Spring Cloud

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 30 May 2015 17:02:00 +0000

Spring Cloud 1.0 is here! It offers a powerful way to create and consume microservices. As you introduce new services, you introduce integration problems: services can be shaky, they can disappear and - as they're often exposed over HTTP - they require a bit more footwork than in-process method invocations. In this webinar, we'll focus specifically on how Spring Cloud integrates service registration (e.g.: Eureka, Consul, or Zookeeper), declarative REST clients (with Netflix's Feign), reactive programming and the circuit breaker pattern with Hystrix to support easy, robust service-to-service invocations.

Source: https://www.youtube.com/watch?v=my3yr8Arq2g

Spring Flo Demo

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sat, 30 May 2015 16:58:00 +0000

HTML5 based canvas for creating data pipelines, analytics dashboards, and monitoring.

Source: https://www.youtube.com/watch?v=17pLpcdIu_M

Efficient Client-Server Communication with Differential Synchronization and JSON Patch

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Wed, 29 Apr 2015 18:06:00 +0000

The world of client-server has changed. The traditional application of REST is no longer the best fit. We're depolying applications into a world where users expect responsive UIs, on all their devices, even while disconnected. We're deploying into a world where connection latency, mobile radio usage and battery life have become primary concerns.

Differential Synchronization (DS) is an algorithm that syncs data across N parties, even in the face of dropped connections, offline devices, etc. It makes more efficient use of connections by batching and sending only changes, in both directions, from client to server and from server to client. We’ll look at how it can be used with JSON Patch to synchronize application data between clients and servers over HTTP Patch, WebSocket, and STOMP, and how it can be integrated into the Spring ecosystem.

Source: https://www.youtube.com/watch?v=Sy5leSgzdeI

Security for Microservices with Spring and OAuth2

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 07 Dec 2014 21:05:00 +0000

OAuth2 is a lightweight security protocol that is well-suited for use with HTTP, the protocol at the heart of many modern architectures. Spring Security OAuth2 has a load of new features, not the least of which being the `@Configuration` support in version 2.0. Combine these with Spring Boot and you have a platform which can get you a secure HTTP service application in about 20 lines of code. This presentation shows how the combination of rapid development and production-ready features in the modern Spring stack are a perfect mixture for developing secure components in a system composed of microservices. We explore the new features in Spring OAuth2, guide you through the choice of which to use and when, and show how easy they are to enable quickly.

Source: https://www.youtube.com/watch?v=MLfL1NpwUC4

IoT Realized with Spring XD - The Connected Car

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 28 Oct 2014 21:38:00 +0000

In this demo we will explore the power of Spring XD in the context of the Internet of Things (IoT). We will look at a solution developed with Spring XD to stream real time analytics from a moving car using open standards. Ingestion of the real time data (location, speed, engine diagnostics, etc), analyzing it to provide highly accurate MPG and vehicle range prediction, as well as providing real time dashboards will all be covered. Watch this demo to get a sense of how Spring XD can serve as “Legos®” for the IoT.

Source : https://www.youtube.com/watch?v=qkm2GV57hzY

Why Do I recommend Spring?

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 28 Oct 2014 21:32:00 +0000

Is Spring the new legacy as quite a few people tell you on their blogs? I disagree on many levels. Throughout this session I will holistically detail without any polemics why I do recommend using the Spring Framework and its ecosystem. Aspects that will be covered include: operational impacts, ecosystem, coding and road maps. This presentation is aimed at IT managers, Architects and Developers alike.

Source: https://www.youtube.com/watch?v=z1rpWpSKtT8

Architecting for Continuous Delivery: Microservices with Pivotal CF and Spring Cloud

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 28 Oct 2014 21:29:00 +0000

Join Matt Stine to hear how you can architect systems that are optimized for continuous delivery, allowing you to innovate and deliver value faster and safer. Microservices, Pivotal CF, and Spring Cloud combine to create an operationalized architecture that enables enterprises to continuously deliver value at scale through rapid, iterative development, and to meet the needs of a mobile-first world.

Introducing Project Wing

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Sun, 31 Aug 2014 18:30:00 +0000

Project Wing is a Google[x] project that is developing a delivery system that uses self-flying vehicles. As part of our research, we built a vehicle and traveled to Queensland, Australia for some test flights. There, we successfully delivered a first aid kit, candy bars, dog treats, and water to a couple of Australian farmers. We’re only just beginning to develop the technology to make a safe delivery system possible, but we think that there’s tremendous potential to transport goods more quickly, safely and efficiently.

Example HTML File to display Overlay using JQuery

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Tue, 12 Aug 2014 21:19:00 +0000

Copy past the below html code into one html file then access the html in browser to see the Overlay functionality.

<html>
<head>
<title>Sample Overlay Test</title>
<link href=”css/jquery-ui.min.css” rel=”stylesheet” type=”text/css” />
<script src=”js/jquery.min.js”></script>
<script src=”js/jquery-ui.min.js”></script>

<style type=”text/css”>
#displayOverLayDiv {
width: 500px;
height: 500px;
display: none;
}

.overlay {
position: absolute;
top: 0;
left: 0;
display: none;
background-color: black;
background: url(“http://malliktalksjava.in”);
}

#frame {
border: 0;
width: 500px;
height: 500px;
}

#open {
border: 0;
width: 175px;
height: 24px;
background-color: #EAF8F8;
font-size: 18 px;
font-weight: bold;
}
</style>

<script type=”text/javascript”>
$(document).ready(function () {
$(‘#open’).click(function () {
$(“.overlay”).height($(window).height());
$(“.overlay”).width($(window).width());
$(“.overlay”).fadeTo(1000, 0.4);
$(“#displayOverLayDiv”).dialog({
width: “auto”,
height: “auto”,
show: {
effect: “slide”,
duration: 1500
},
hide: {
effect: “slide”,
duration: 1500
},
beforeClose: function () {
$(“.overlay”).fadeTo(1000, 0);
},
close: function () {
$(“.overlay”).css(“display”, “none”);
},
resizeStop: function (event, ui) {
$(“#frame”).height($(this).height());
$(“#frame”).width($(this).width());
}
});
});
});
</script>
</head>

<body>
<div id=’open’>
<a href=”#”>Click here to Get Overlay</a>
</div>
<div class=’overlay’>
<div id=’displayOverLayDiv’>

</div>
</div>
</body>
</html>

REST-ful API Evolution

mallikarjungunda@gmail.com (Mallikarjun Gunda) — Wed, 23 Jul 2014 22:20:00 +0000

As REST-ful data services become more widespread, it is becoming clear that they have to change to suit new consumer needs. This evolution is often disruptive to consumers, but it doesn't have to be. This session, a follow up to 'REST-ful API Design', discusses various strategies for evolving a REST-ful API and how the strategies can be implemented using Spring.

Source: https://www.youtube.com/watch?v=fSFh9UCBp5s&list=UU7yfnfvEUlXUIfm8rGLwZdA