How does one go about doing end-to-end testing of a distributed in-memory database such as Pivotal GemFire? Presented at JVM Meetup Sydney https://www.meetup.com/Sydney-JVM-Community/events/233465115/ Demo code available at: https://github.com/d-lorenc/junit-docker-demo
GWT brings a lot to the table on the client side: the comprehensive browser compatibility and the ease of writing in java are just a few examples to name. But, when looking at the server side, GWT can be a bit lacking with the technologies it uses. Learn how to build powerful end to end Enterprise applications with GWT as your frontend and how to back it up with your favorite arsenal of tools, including, Spring, Guice and Hibernate
- 진행: 유정협 (Justin Yoo) - Mexia Consulting - 설명: https://event.openinfradays.kr/2018/workshop2/20-track-4
This document discusses different types of virtualization and containers, effective usage of infrastructure resources when running projects in containers versus virtual machines, and scaling approaches. It also covers pay-per-use pricing models versus pay-as-you-go, challenges of managing Kubernetes clusters, and how a Platform as a Service provider can help address these challenges through automated deployment and management of Kubernetes clusters with integrated monitoring, self-healing, and pay-per-actual-use pricing.
WLST is a scripting tool that allows automation of WebLogic domain configuration and management. Key benefits of using WLST to automate domain builds include consistency across environments, the ability to quickly build new environments, facilitating disaster recovery, and maintaining consistency over time. The main steps in automating domain builds are installing software silently, creating the base domain configuration from a template or existing domain using WLST scripts, and further customizing the domain configuration with additional WLST scripts.
Kubernetes has rapidly established itself as the de facto standard for orchestrating containerized infrastructures. And with the recent completion of the refactoring of Flink's deployment and process model known as FLIP-6, Kubernetes has become a natural choice for Flink deployments. In this talk we will walk through how to get Flink running on Kubernetes
What happened when our biggest and most important Kafka cluster went rogue all of a sudden, and while trying to recover it, a single, crucial misconfiguration made things even worse? At a company like Taboola, where service availability and latency are our top priority, this was a disaster. With 300K messages/sec and 250TB of messages produced each day to our on-premise Kafka clusters, and mirrored to our central Kafka cluster, we always try to ensure Kafka behaves well under high loads of traffic and unexpected cluster failures. So when our main Kafka cluster went crazy we had a serious issue on our hands. This session is the story of how we learned the hard way about mitigating cluster failures with the proper configurations in place.
One of the main sources of concerns when switching to the container paradigm is security. When dealing with big amounts of sensitive customer data it’s very important to be able to guarantee that the data is transported safely between the different components of the system. This talk will focus on how to setup a Flink cluster to run on a Kubernetes environment taking into account all security aspects to ensure secured communication between the nodes of the cluster, state backend and also for job submission, all taking advantage of Kubernetes tools.
Watch this talk here: https://www.confluent.io/online-talks/how-apache-kafka-works-on-demand Pick up best practices for developing applications that use Apache Kafka, beginning with a high level code overview for a basic producer and consumer. From there we’ll cover strategies for building powerful stream processing applications, including high availability through replication, data retention policies, producer design and producer guarantees. We’ll delve into the details of delivery guarantees, including exactly-once semantics, partition strategies and consumer group rebalances. The talk will finish with a discussion of compacted topics, troubleshooting strategies and a security overview. This session is part 3 of 4 in our Fundamentals for Apache Kafka series.
This session provides an overview of how to build and deploy Spring-based applications to the Cloud Foundry platform. The session will cover application configuration parameters, binding services to your application, deployment options using using STS, the vmc command tool, as well as the new Apache Maven plugin for Cloud Foundry. Gunnar will demonstrate how to deploy applications to both micro and public Cloud Foundry and will also show how debugging works with Cloud Foundry and how you can inspect services remotely using Caldecott. Gunnar will also show various options to keep your War-files deployable to both Cloud Foundry and stand-alone Servlet Containers using auto-reconfiguration, the cloud namespace, and Spring 3.1 profiles. Lastly, he will give a high-level overview how you can use Cloud Foundry together with Spring Integration in order to create scalable Spring applications.
The document discusses various techniques for optimizing Java application performance on Kubernetes, including: 1. Using optimized container images that are small in size and based on Alpine Linux. 2. Configuring the JVM to use container resources efficiently through settings like -XX:MaxRAMPercentage instead of hardcoded heap sizes. 3. Setting appropriate resource requests and limits for pods to ensure performance isolation and prevent throttling. 4. Leveraging tools like Kubernetes' Horizontal Pod Autoscaler and Pod Disruption Budget for scaling and high availability. 5. Tuning both software and hardware settings for optimal performance of Java workloads on Kubernetes.
The next generation of VCS has a clear target ahead of them: making branching and merging easier. Until recently, Subversion was dominating the world of Version Control Systems, but now, Distributed Version Control Systems are growing in popularity and everywhere you go you hear about Git or Mercurial, and how they make branching and merging a breeze. But the Subversion team isn't going down quietly, they have a new weapon: the 1.5 version. Learn about the next generation of Version Control Systems is planning to solve your problems.
Presented at Open Source Summit Japan with Jonathan Schweikhart on June 21, 2018. Abstract: The 40 Node.js microservices making up the IBM Cloud UI historically have been deployed as apps on Cloud Foundry (CF), an open source PaaS. But, recently, this enterprise microservice system has been migrated to run on Kubernetes to take advantage of improved orchestration, higher availability, and better performance. Tony Erwin & Jonathan Schweikhart will discuss their team's journey and provide you with insights into the advantages of Kube over CF. Even more importantly, they will describe approaches to solving new problems that took the place of old ones, such as: 1) adapting PaaS apps to run as containers on Kube, 2) enabling geo load balancing between the different runtimes (to vette Kube before completely turning off CF), 3) integrating tools like Prometheus into existing monitoring systems, and more! Their team's first-hand experiences will help you avoid pitfalls as you prepare your own migrations to Kube! Link to Info on Talk: https://ossalsjp18.sched.com/event/EaYj/migration-of-an-enterprise-ui-microservice-system-from-cloud-foundry-to-kubernetes-tony-erwin-jonathan-schweikhart-ibm?iframe=no NOTE: CF is always evolving and the limitations on private networking and private host names mentioned in the slides are no longer current. If you have access to CF API 2.115.0 or higher (released on June 25, 2018), you can leverage CF's service discovery feature (see https://docs.cloudfoundry.org/devguide/deploy-apps/cf-networking.html#discovery ).
ContextSpace is working to develop and support an open source implementation of the Camunda core engine that persists all if its data to Cassandra. This development addresses issues of ACID as well as approaches to lock management. ContextSpace plans to integrate this implementation with its own product offering in order to expose data and events generated from its identity, security, roles, messaging and contextual user activities to be managed by Camunda-driven business processes.
ElasticBox Lead Architect Arnaud Bonnet's presentation from the March 18, 2016 Seattle Kubernetes meetup hosted by StackPointCloud. Arnaud gives us a great overview of ElasticKube, a Kubernetes container management platform, and what's ahead for the open source project. Join us in Seattle: http://www.meetup.com/Seattle-Kubernetes-Meetup/
A practical look at the different strategies to deploy an application to Kubernetes. We list the pros and cons of each strategy and define which one to adopt depending on real world examples and use cases.
This presentation includes information on Kubernetes Architecture, Container Orchestration, Internal Routing, External Routing, Configuration Management, Credentials Management, Persistent Volumes, Rolling Out Updates, Autoscaling, Package Management, and a Hello World example using Helm.
An in depth overview of Kubernetes and it's various components. NOTE: This is a fixed version of a previous presentation (a draft was uploaded with some errors)
Auckland CI slide deck on using Docker, SpringBoot, Docker Compose and Junit for Integration testing.
Fast and efficient software testing is easy with Docker. We often use containers to maintain parity across development, testing, and production environments, but we can also use containerization to significantly reduce time needed for testing by spinning up multiple instances of fully isolated testing environments and executing tests in parallel. This strategy also helps you maximize the utilization of infrastructure resources. The enhanced toolset provided by Docker makes this process simple and unobtrusive, and you’ll see how Docker Engine, Registry, and Compose can work together to make your tests fast.
This presentation provides an overview of Docker concepts and commands for Java developers. It covers creating Docker hosts, running containers, building images, running applications in Docker, linking containers, composing with Docker Compose, and an overview of Docker Swarm clustering. Live coding examples are shown for many of the Docker commands and concepts.