Claus Ibsen's presentation during Red Hat's "Microservices Journey with Apache Camel" events that took place in Atlanta on Oct 4th and Minneapolis on Oct 6th.
Continuous Testing helps provide process improvements that can prevent future defects from occurring. It plays an important role in providing continuous feedback for your software.
This document discusses microservices and OSGi services running with Apache Karaf. It covers some of the operational overhead and complexity of microservices compared to using OSGi microservices (μServices) with Apache Karaf. Key points include reduced operational overhead and skills requirements, built-in support for versioning and distributed capabilities with OSGi μServices in Apache Karaf. Continuous delivery techniques like using Jolokia for deployment and Apache Karaf Cellar for clustering are also mentioned.
SkyBase - a Devops Platform for Hybrid CloudVlad Kuusk
Skybase system is a DevOps platform designed to be used for deployment and maintenance of Services inside all locations of an organization including Dev, QA, Prod and different clouds and geographic regions and data centers.
Data Labs supports LINE services by performing high-level data analysis and machine learning model development using their Hadoop data lake. The machine learning lifecycle involves many steps beyond just model training, including data collection, preprocessing, deployment, and monitoring. LINE's platform provides the necessary infrastructure to efficiently perform each step of the lifecycle, allowing for rapid continuous development and experimentation through tools like HDFS, Kubernetes, Jupyter notebooks, and CI/CD pipelines.
Netflix uses Conductor, an open source microservices orchestrator, to manage complex content processing workflows involving ingestion, encoding, localization, and delivery. Conductor provides visibility, control, and reuse of tasks through a task queuing system and workflow definitions. It has scaled to process millions of workflow executions across Netflix's content platform using a stateless architecture with Dynomite for storage and Dyno-Queues for task distribution.
Mariusz Richtscheid: Are you wondering about using serverless computing in your project? In this presentation, I will explain the basics of serverless architecture. I'm using an example of a real-life serverless project done at The Software House called Babelsheet (translation-management solution), and include many practical tips for any beginner starting their adventure with a serverless architecture.
Manchester MuleSoft Meetup #6 - Runtime Fabric with Mulesoft Akshata Sawant
Come join us at the Online Meetup to learn more about ServiceNow and Gmail Integration with MuleSoft with detailed Demo. Help us spread the knowledge of Mule!
A brief agenda:
> Networking and Knowledge sharing.
> MuleSoft Latest Product Release Updates.
> Runtime Fabric in depth architecture.
> Finally, we will wrap-up this event with the agenda for the next meetup.
Stay connected to get updates on what's new in MuleSoft.
SpringBoot and Spring Cloud Service for MSAOracle Korea
Cloud 환경에서 MSA를 하기 위해서 Service Discovery, Circuit Breaker 등을 사용하여 Application을 개발하는 방법과 SpringBoot 와 Spring Cloud Service 를 사용하는데, Cloud에서 Kubernetes를 위시한 Container 생태계가 어떻게 MSA에 영향을 미치는지 알아봅니다.
Continuous Testing helps provide process improvements that can prevent future defects from occurring. It plays an important role in providing continuous feedback for your software.
This document discusses microservices and OSGi services running with Apache Karaf. It covers some of the operational overhead and complexity of microservices compared to using OSGi microservices (μServices) with Apache Karaf. Key points include reduced operational overhead and skills requirements, built-in support for versioning and distributed capabilities with OSGi μServices in Apache Karaf. Continuous delivery techniques like using Jolokia for deployment and Apache Karaf Cellar for clustering are also mentioned.
SkyBase - a Devops Platform for Hybrid CloudVlad Kuusk
Skybase system is a DevOps platform designed to be used for deployment and maintenance of Services inside all locations of an organization including Dev, QA, Prod and different clouds and geographic regions and data centers.
Data Labs supports LINE services by performing high-level data analysis and machine learning model development using their Hadoop data lake. The machine learning lifecycle involves many steps beyond just model training, including data collection, preprocessing, deployment, and monitoring. LINE's platform provides the necessary infrastructure to efficiently perform each step of the lifecycle, allowing for rapid continuous development and experimentation through tools like HDFS, Kubernetes, Jupyter notebooks, and CI/CD pipelines.
Netflix uses Conductor, an open source microservices orchestrator, to manage complex content processing workflows involving ingestion, encoding, localization, and delivery. Conductor provides visibility, control, and reuse of tasks through a task queuing system and workflow definitions. It has scaled to process millions of workflow executions across Netflix's content platform using a stateless architecture with Dynomite for storage and Dyno-Queues for task distribution.
Mariusz Richtscheid: Are you wondering about using serverless computing in your project? In this presentation, I will explain the basics of serverless architecture. I'm using an example of a real-life serverless project done at The Software House called Babelsheet (translation-management solution), and include many practical tips for any beginner starting their adventure with a serverless architecture.
Manchester MuleSoft Meetup #6 - Runtime Fabric with Mulesoft Akshata Sawant
Come join us at the Online Meetup to learn more about ServiceNow and Gmail Integration with MuleSoft with detailed Demo. Help us spread the knowledge of Mule!
A brief agenda:
> Networking and Knowledge sharing.
> MuleSoft Latest Product Release Updates.
> Runtime Fabric in depth architecture.
> Finally, we will wrap-up this event with the agenda for the next meetup.
Stay connected to get updates on what's new in MuleSoft.
SpringBoot and Spring Cloud Service for MSAOracle Korea
Cloud 환경에서 MSA를 하기 위해서 Service Discovery, Circuit Breaker 등을 사용하여 Application을 개발하는 방법과 SpringBoot 와 Spring Cloud Service 를 사용하는데, Cloud에서 Kubernetes를 위시한 Container 생태계가 어떻게 MSA에 영향을 미치는지 알아봅니다.
This document summarizes an agenda for a presentation on the open-source cloud-native programming language Ballerina. The presentation covers topics like services, HTTP/GraphQL, concurrency, asynchronous I/O, Kubernetes deployment, serverless computing on AWS Lambda and Azure Functions, and observability using distributed tracing and metrics. It also lists additional Ballerina features and provides information on how to get involved with the Ballerina community.
How is automation done in real world (and) on existing systems. This webcast shows our way from existing handmade installations to ansible playbook managed environment.
Why did we choose ansible over others? A demo shows installation and how automation tools can reduce stress during incident remediation situations.
Your Auto-Scaling Bot - Volkan TufeckiDocker, Inc.
In this talk we will talk about a docker swarm architecture that scales automatically with the help of a Slack Bot. The talk will include - Docker Swarm and Docker Compose - Monitoring containers by cadvisor - Managing alerts with promotheus and alert manager - Running a slack bot that decides to deploy or undeploy services - Generating load with siege
Continuous delivery with jenkins pipelines (@WeAreDevelopers2017)Roman Pickl
Roman Pickl is the CTO of Fluid4me and has been using Jenkins since 2012. He gives a presentation on continuous delivery with Jenkins Pipelines. Jenkins is an open source tool for continuous integration and delivery that has over 100,000 active installations. The presentation demonstrates how to set up a Jenkinsfile and pipeline in code to automate building, testing, and deploying applications. It also shows Blue Ocean, a new user interface for visualizing and editing Jenkins pipelines.
Atagg2015 Continuous delivery by building environment using dockerAgile Testing Alliance
The document discusses how PayUMoney uses Docker containers to enable continuous delivery. It outlines challenges with limited testing environments and long setup times. PayUMoney developed a standardized Docker setup to allow anyone on the team to quickly spin up production-like environments on their own laptops. This enabled automated testing of all code branches, fast merging to mainline, and continuous deployment to production with zero downtime releases. Speakers Nitin Mukhija and Tarun Lalwani from PayUMoney presented on how Docker simplified their environment management and improved their delivery process.
This document discusses Git strategies for teams. It outlines several branching strategies including "wing and a prayer", long-running branches, Git flow, and branch-per-feature. Git flow uses long-running branches with specific rules for features, hotfixes, bugs, and only merging develop branches to master once stable. Branch-per-feature creates a new branch for each feature or change and nothing is merged until production deployment. The document also discusses automation, team composition, environments, and selection criteria to consider when choosing a branching strategy.
This document discusses GitLab Continuous Integration (GitLab CI/CD). It defines continuous integration, continuous delivery, and continuous deployment. It explains that GitLab CI/CD uses pipelines made up of stages and jobs to test, build, and deploy code. Pipelines are configured using a YAML file. Jobs run on GitLab runners, which can execute jobs locally or using Docker. Benefits of GitLab CI/CD include integrated pipelines, Docker/Kubernetes integration, and not requiring plugins. The downside is that it is only available within GitLab.
This document outlines an introduction to Docker for Java developers, including running Java microservices and applications in Docker containers. It discusses building Docker images with Maven, interacting with the Docker API in Java, continuous delivery with Jenkins and Docker, and deploying Java applications to production using Docker clusters like Kubernetes and Docker Swarm.
Deploying Flink on Kubernetes - David AndersonVerverica
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
Battle Of The Microservice Frameworks: Micronaut versus Quarkus edition! Michel Schudel
Micronaut and Quarkus are two cool emerging Java backend frameworks that aim to solve some problems that exist in current frameworks, like faster startup, low memory footprint, and support for ahead-of-time compilation using GraalVM. In this session, we'll square off both frameworks against each other.
How do they compare, what are the stronger and weaker points of both frameworks?
We'll compare the following features:
Initializing your project
Building your first restcontroller / programming model
Startup time
Database support
Integration test support
Building native images
Memory usage and JAR sizes
Ease of cloud deployment
In the end, we might have a clear winner! ... or will we?
WebSockets allow for bi-directional communication between a client and server that reduces overhead compared to traditional HTTP requests. This enables real-time updates and instant notifications. Common use cases include chat applications, data feeds that change frequently, and workflow notifications. While browser support is now widespread, adoption has been slowed by compatibility with older browsers, SEO concerns, and firewall configurations that expect HTTP. The Socket.io library makes it easy to use WebSockets with Node.js. Demonstrations show WebSockets enabling a hot potato game, updating app data in real-time, and powering a chat room.
Talk given at OpenResty Con 2017 in Beijing.
Kong (https://getkong.org) is a widely-adopted open source API Gateway built with OpenResty. It aims at helping secure, manage, and extend microservices-based architectures with minimal effort from the user, while ensuring platform agnosticism.
In this talk, we will explore the challenges we encountered developing such an OpenResty application, and how we overcame many of them by way of libraries and contributions back to the OpenResty community. We will cover topics such as clustering OpenResty nodes, inter-workers communication, DNS resolution, typical pitfalls OpenResty developers should avoid, and much more.
Machine learning with Apache Spark on Kubernetes | DevNation Tech TalkRed Hat Developers
The first challenge for an AI/ML practitioner is to gather the data inputs needed to feed a learning model. This is where a solution such as Apache Spark’s unified DataFrame API and a scale-out compute model allows you to execute parallelized queries against SQL, Kafka, and S3. In this session, we are going to explore the use of https://radanalytics.io/ and https://opendatahub.io/ on top of Kubernetes/OpenShift to demonstrate a dynamically scalable ETL pipeline for federated data ingestion.
Presented at GR8Conf US 2016 in Minneapolis, MN.
You've got your microservices, cloud config & Eureka servers running in development, but how do you take that to production? A single instance of each isn't a viable solution for these critical services. In this talk, we'll walk through how to configure and run the cloud config and Eureka servers in a high availability manner. We will also cover other production tasks like pushing config updates and monitoring all your Hystrix circuit breakers using Turbine. This is not an introductory talk and assumes a basic familiarity with the Spring Cloud Services.
How to monitor your Java micro-service with Prometheus? How to design metrics, what is USE and RED? Metrics for a REST service with Prometheus, AlertManager, and Grafana.
Slides and live-coding demo from Warsaw Java User Group Meetup in Warsaw #238.
Victor introduces Swagger, an open-source framework for describing, producing, consuming, and visualizing RESTful APIs. Swagger allows API developers to describe the structure of APIs, including operations and models, using JSON or YAML files. It also generates documentation from these files and allows for testing API operations in interactive documents.
The document discusses best practices for building and deploying Scala applications based on the 12 Factor App methodology. It covers topics like managing dependencies, separating configuration from code, building in a simple and automated way, scaling apps through stateless processes, achieving parity between development and production environments, and running admin tasks isolated from the main app. The presentation provides examples using tools like sbt, Dropwizard, and Heroku to demonstrate how to structure Scala apps according to the 12 factors.
The document provides an introduction to Java Enterprise Edition (Java EE) including:
1. An overview of what Java EE is, its key deliverables and basic multi-tier architecture with components and containers.
2. The benefits of Java EE for developers, vendors and businesses including application portability and large developer community support.
3. A brief description of the most common Java EE technologies, specifications, APIs and how applications are assembled and deployed on Java EE platforms.
The document outlines a 6 step Java EE web application course. It includes videos on Java servlets, JSP, JSTL, and a real world application. It provides an overview of the request flow and basic architecture of a real world application. Course links are provided for additional Java, Spring, and testing tutorials.
This document summarizes an agenda for a presentation on the open-source cloud-native programming language Ballerina. The presentation covers topics like services, HTTP/GraphQL, concurrency, asynchronous I/O, Kubernetes deployment, serverless computing on AWS Lambda and Azure Functions, and observability using distributed tracing and metrics. It also lists additional Ballerina features and provides information on how to get involved with the Ballerina community.
How is automation done in real world (and) on existing systems. This webcast shows our way from existing handmade installations to ansible playbook managed environment.
Why did we choose ansible over others? A demo shows installation and how automation tools can reduce stress during incident remediation situations.
Your Auto-Scaling Bot - Volkan TufeckiDocker, Inc.
In this talk we will talk about a docker swarm architecture that scales automatically with the help of a Slack Bot. The talk will include - Docker Swarm and Docker Compose - Monitoring containers by cadvisor - Managing alerts with promotheus and alert manager - Running a slack bot that decides to deploy or undeploy services - Generating load with siege
Continuous delivery with jenkins pipelines (@WeAreDevelopers2017)Roman Pickl
Roman Pickl is the CTO of Fluid4me and has been using Jenkins since 2012. He gives a presentation on continuous delivery with Jenkins Pipelines. Jenkins is an open source tool for continuous integration and delivery that has over 100,000 active installations. The presentation demonstrates how to set up a Jenkinsfile and pipeline in code to automate building, testing, and deploying applications. It also shows Blue Ocean, a new user interface for visualizing and editing Jenkins pipelines.
Atagg2015 Continuous delivery by building environment using dockerAgile Testing Alliance
The document discusses how PayUMoney uses Docker containers to enable continuous delivery. It outlines challenges with limited testing environments and long setup times. PayUMoney developed a standardized Docker setup to allow anyone on the team to quickly spin up production-like environments on their own laptops. This enabled automated testing of all code branches, fast merging to mainline, and continuous deployment to production with zero downtime releases. Speakers Nitin Mukhija and Tarun Lalwani from PayUMoney presented on how Docker simplified their environment management and improved their delivery process.
This document discusses Git strategies for teams. It outlines several branching strategies including "wing and a prayer", long-running branches, Git flow, and branch-per-feature. Git flow uses long-running branches with specific rules for features, hotfixes, bugs, and only merging develop branches to master once stable. Branch-per-feature creates a new branch for each feature or change and nothing is merged until production deployment. The document also discusses automation, team composition, environments, and selection criteria to consider when choosing a branching strategy.
This document discusses GitLab Continuous Integration (GitLab CI/CD). It defines continuous integration, continuous delivery, and continuous deployment. It explains that GitLab CI/CD uses pipelines made up of stages and jobs to test, build, and deploy code. Pipelines are configured using a YAML file. Jobs run on GitLab runners, which can execute jobs locally or using Docker. Benefits of GitLab CI/CD include integrated pipelines, Docker/Kubernetes integration, and not requiring plugins. The downside is that it is only available within GitLab.
This document outlines an introduction to Docker for Java developers, including running Java microservices and applications in Docker containers. It discusses building Docker images with Maven, interacting with the Docker API in Java, continuous delivery with Jenkins and Docker, and deploying Java applications to production using Docker clusters like Kubernetes and Docker Swarm.
Deploying Flink on Kubernetes - David AndersonVerverica
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
Battle Of The Microservice Frameworks: Micronaut versus Quarkus edition! Michel Schudel
Micronaut and Quarkus are two cool emerging Java backend frameworks that aim to solve some problems that exist in current frameworks, like faster startup, low memory footprint, and support for ahead-of-time compilation using GraalVM. In this session, we'll square off both frameworks against each other.
How do they compare, what are the stronger and weaker points of both frameworks?
We'll compare the following features:
Initializing your project
Building your first restcontroller / programming model
Startup time
Database support
Integration test support
Building native images
Memory usage and JAR sizes
Ease of cloud deployment
In the end, we might have a clear winner! ... or will we?
WebSockets allow for bi-directional communication between a client and server that reduces overhead compared to traditional HTTP requests. This enables real-time updates and instant notifications. Common use cases include chat applications, data feeds that change frequently, and workflow notifications. While browser support is now widespread, adoption has been slowed by compatibility with older browsers, SEO concerns, and firewall configurations that expect HTTP. The Socket.io library makes it easy to use WebSockets with Node.js. Demonstrations show WebSockets enabling a hot potato game, updating app data in real-time, and powering a chat room.
Talk given at OpenResty Con 2017 in Beijing.
Kong (https://getkong.org) is a widely-adopted open source API Gateway built with OpenResty. It aims at helping secure, manage, and extend microservices-based architectures with minimal effort from the user, while ensuring platform agnosticism.
In this talk, we will explore the challenges we encountered developing such an OpenResty application, and how we overcame many of them by way of libraries and contributions back to the OpenResty community. We will cover topics such as clustering OpenResty nodes, inter-workers communication, DNS resolution, typical pitfalls OpenResty developers should avoid, and much more.
Machine learning with Apache Spark on Kubernetes | DevNation Tech TalkRed Hat Developers
The first challenge for an AI/ML practitioner is to gather the data inputs needed to feed a learning model. This is where a solution such as Apache Spark’s unified DataFrame API and a scale-out compute model allows you to execute parallelized queries against SQL, Kafka, and S3. In this session, we are going to explore the use of https://radanalytics.io/ and https://opendatahub.io/ on top of Kubernetes/OpenShift to demonstrate a dynamically scalable ETL pipeline for federated data ingestion.
Presented at GR8Conf US 2016 in Minneapolis, MN.
You've got your microservices, cloud config & Eureka servers running in development, but how do you take that to production? A single instance of each isn't a viable solution for these critical services. In this talk, we'll walk through how to configure and run the cloud config and Eureka servers in a high availability manner. We will also cover other production tasks like pushing config updates and monitoring all your Hystrix circuit breakers using Turbine. This is not an introductory talk and assumes a basic familiarity with the Spring Cloud Services.
How to monitor your Java micro-service with Prometheus? How to design metrics, what is USE and RED? Metrics for a REST service with Prometheus, AlertManager, and Grafana.
Slides and live-coding demo from Warsaw Java User Group Meetup in Warsaw #238.
Victor introduces Swagger, an open-source framework for describing, producing, consuming, and visualizing RESTful APIs. Swagger allows API developers to describe the structure of APIs, including operations and models, using JSON or YAML files. It also generates documentation from these files and allows for testing API operations in interactive documents.
The document discusses best practices for building and deploying Scala applications based on the 12 Factor App methodology. It covers topics like managing dependencies, separating configuration from code, building in a simple and automated way, scaling apps through stateless processes, achieving parity between development and production environments, and running admin tasks isolated from the main app. The presentation provides examples using tools like sbt, Dropwizard, and Heroku to demonstrate how to structure Scala apps according to the 12 factors.
The document provides an introduction to Java Enterprise Edition (Java EE) including:
1. An overview of what Java EE is, its key deliverables and basic multi-tier architecture with components and containers.
2. The benefits of Java EE for developers, vendors and businesses including application portability and large developer community support.
3. A brief description of the most common Java EE technologies, specifications, APIs and how applications are assembled and deployed on Java EE platforms.
The document outlines a 6 step Java EE web application course. It includes videos on Java servlets, JSP, JSTL, and a real world application. It provides an overview of the request flow and basic architecture of a real world application. Course links are provided for additional Java, Spring, and testing tutorials.
This document discusses integrating legacy applications using Apache Camel. Camel provides abstractions that make it easy to integrate applications that use different protocols and technologies. It allows defining retry and transaction policies for integrations. While Camel is good for integration, very large projects may be better broken into microservices and APIs. Writing unit tests for Camel integrations can also be challenging. The document provides further reading resources on integration patterns, the Camel cookbook, and Camel components.
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.
Apache Syncope is a powerful and flexible open-source Identity Management solution. Apache Camel is an integration framework that comes with a huge list of messaging components. Wouldn't it be cool to be able to plug in an integration framework like Camel into an Identity Management solution like Syncope, so that you can easily write custom routing and mediation rules for Identity provisioning?
Well with Syncope 2.0.0 you can do just this with the new Apache Camel provisioning manager! In this talk, we will provide an overview of the exciting new features available in the Apache Syncope 2.0.0 release. In particular, we will focus on how it integrates with Apache Camel. We will go through some practical use-cases to illustrate how to exploit this new feature.
Developing Microservices with Apache CamelClaus Ibsen
Red Hat Microservices Architecture Day - New York, November 2015. Presented by Claus Ibsen.
Apache Camel is a very popular integration library that works very well with microservice architecture. This talk introduces you to Apache Camel and how you can easily get started with Camel on your computer. Then we cover how to create new Camel projects from scratch as microservices, which you can boot using Camel or Spring Boot, or other micro containers such as Jetty or fat JARs. We then take a look at what options you have for monitoring and managing your Camel microservices using tooling such as Jolokia, and hawtio web console.
Apache Camel is swiss knife for integration architectural problems. A full implementation of EIP and Loaded with hundreds of components it is the de-facto standard in solving Integration problems.
With a strong focus on annotations, minimalist configuration, simple deployment, intelligent defaults and Java centric type-safety, Java EE is one of the most productive full-stack development platforms around today. This very code centric workshop is a quick tour of the Java EE platform as it stands today. If you haven't seen Java EE for a while and want to catch up, this session is definitely for you.
We will start with the basic principals of what Java EE is and what it is not, overview the platform at a high level and then dive into each key API like JSF, CDI, EJB 3, JPA, JAX-RS, WebSocket and JMS using examples and demos. This is your chance to look at Java EE 7 in the context of a realistic application named Cargo Tracker, available with an MIT license at http://cargotracker.java.net.
We will also briefly take a look at the emerging horizons of Java EE 8.
This document provides an overview and introduction to Apache Camel, an open-source integration library. It discusses what integration is and why it is difficult. It then introduces Apache Camel as a lightweight integration library that uses enterprise integration patterns and components to provide routing, mediation, and transformation capabilities. The document provides examples of how to define integration logic in Camel using Java and XML domain-specific languages. It also discusses Camel's support for enterprise integration patterns, pre-built components, testing framework, and management capabilities.
SpringBoot is a framework that makes it easy to create Spring-based applications and services. It provides starter dependencies, centralized configuration, production-ready features, and good testing capabilities out of the box. While static content serving and mixing Jersey and Spring MVC can be issues, overall SpringBoot simplifies development. Apache Camel is an open source integration framework that uses enterprise integration patterns to provide a library of pre-built components for connecting applications together. It has many components but documentation is limited, creating a learning curve.
Java EE 8 will include updates to several existing specifications as well as new specifications. Key updates include JMS 2.1, JAX-RS 2.1, JSF 2.3, CDI 2.0, and JSON-P 1.1. New specifications include JCache 1.0, JSON-B 1.0, MVC 1.0, and Java EE Security API 1.0. Java EE 8 is currently in development, with early drafts of specifications and milestones available to provide feedback on. A final release is planned for Q3 2016.
We start with an introduction to what Apache Camel is, and how you can use Camel to make integration much easier. Allowing you to focus on your business logic, rather than low level messaging protocols, and transports. You will also hear what other features Camel provides out of the box, which can make integration much easier for you.
We look into web console tooling that allows you to get insight into your running Apache Camel applications, which has among others visual route diagrams with tracing/debugging and profiling capabilities. In addition to the web tooling we will also show you other tools in the making.
This document discusses and compares different Java microservice platforms: Payara Micro, WildFly Swarm, and Spring Boot. It defines microservices as independent, deployable services that work together using APIs. It outlines some principles of microservice architecture like componentization via services and decentralized data management. It then evaluates the three platforms on features like composability, file size, boot time, and memory usage. Payara Micro is derived from GlassFish and designed to be elastic, container friendly, and have a small footprint. WildFly Swarm generates an uber jar and integrates with other Red Hat projects. Spring Boot encapsulates Spring and automatically configures standalone applications with minimal configuration. In conclusions, the document finds that while each platform
We start with an introduction to what Apache Camel is, and how you can use Camel to make integration much easier. Allowing you to focus on your business logic, rather than low level messaging protocols, and transports.
You will hear how Apache Camel is related Enterprise Integration
Patterns which you can use in your architectural designs and as well in Java or XML code, running on the JVM with Camel.
You will also hear what other features Camel provides out of the box, which can make integration much easier for you.
We also take a moment to look at web console tooling that allows you to get insight into your running Apache Camel applications, which has among others visual route diagrams with tracing/debugging and profiling capabilities. In addition to the web tooling we will also show you other tools in the making.
This talk was presented at JDKIO on September 13th 2016.
ApacheCon EU 2016 - Apache Camel the integration libraryClaus Ibsen
This presentation will demonstrate to developers involved with integration how the Apache Camel project can make your life much easier.
We start with an introduction to what Apache Camel is, and how you can use Camel to make integration much easier. Allowing you to focus on your business logic, rather than low level messaging protocols, and transports.
You will hear how Apache Camel is related Enterprise Integration Patterns which you can use in your architectural designs and as well in Java or XML code, running on the JVM with Camel.
You will also hear what other features Camel provides out of the box, which can make integration much easier for you.
JavaScript Frameworks and Java EE – A Great MatchReza Rahman
JavaScript frameworks are becoming more popular for building rich clients. Java EE is well-positioned as a backend for JavaScript rich clients, providing capabilities like JAX-RS for REST, the Java API for WebSocket, and JSON processing. The document presents an architecture with the client handling UI rendering and basic logic and the server managing business logic, data, and communication via REST, WebSocket, and server-sent events. It provides a demo on GitHub showing how Java EE can integrate with JavaScript frameworks.
Developing Java based microservices ready for the world of containersClaus Ibsen
The so-called experts are saying microservices and containers will
change the way we build, maintain, operate, and integrate
applications. This talk is intended for Java developers who wants to hear and see how you can develop Java microservices that are ready to run in containers.
In this talk we will build a set of Java based Microservices that uses a mix of technologies with Apache Camel, Spring Boot and WildFly Swarm.
You will see how we can build small discrete microservices with these Java technologies and build and deploy on the Kubernets container platform.
We will discuss practices how to build distributed and fault tolerant microservices using technologies such as Kubernetes Services, Camel EIPs, and Netflixx Hysterix.
And the self healing and fault tolerant aspects of the Kubernetes platform is also discussed and demoed when we let the chaos monkeys loose killing containers.
This talk is a 50/50 mix between slides and demo.
The talk was presented at JDKIO on September 13th 2016.
Developing Java based microservices ready for the world of containersClaus Ibsen
Developing Java based microservices ready for the world of containers
The so-called experts are saying microservices and containers will change the way we build, maintain, operate, and integrate applications. This talk is intended for Java developers who wants to hear and see how you can develop Java microservices that are ready to run in containers.
In this talk we will build a set of Java based Microservices that uses a mix of technologies with:
- Spring Boot with Apache Camel
- Apache Tomcat with Apache Camel
You will see how we can build small discrete microservices with these Java technologies and build and deploy on the Kubernets/OpenShift3 container platform.
We will discuss practices how to build distributed and fault tolerant microservices using technologies such as Kubernetes Services, Camel EIPs, Netflixx Hysterix, and Ribbon.
We will use Zipkin service tracing across all four Java based microservices to provide a visualization of timings and help highlight latency problems in our mesh of microservices.
And the self healing and fault tolerant aspects of the Kubernetes/OpenShift3 platform is also discussed and demoed when we let the chaos monkeys loose killing containers.
This talk is a 50/50 mix between slides and demo.
Meetup Melbourne August 2017 - Agile Integration with Apache Camel microservi...Claus Ibsen
How to get started developing Camel microservices (or any Java technology for that matter) on a local Kubernetes cluster from zero to deployment.
As a Java developer it may be daunting to know how to get started how to develop container applications that runs on Kubernetes cluster.
Using minikube its very easy to run a local cluster and with the help of fabric8 tooling its even easier to install and run using familiar tools like Maven. In this talk we will build a set of Apache Camel and Java based Microservices that uses Spring Boot and WildFly Swarm. With the help of fabric8 maven tooling you will see how to build, deploy, and run your Java projects on a Kubernetes cluster (local or remote). And even live debugging is easy to do as well.
We will discuss practices how to build distributed and fault tolerant microservices using technologies such as Kubernetes Services, Netflix Hysterix, and Camel EIP patterns for fault tolerance. In the talk you will also hear about related open source projects where you can go explore more such as fabric8, openshift.io, istio, etc. This presentation is a 50/50 mix between slides and demo.
Riga Dev Day 2016 - Microservices with Apache Camel & fabric8 on KubernetesClaus Ibsen
This document discusses microservices with Apache Camel and fabric8 on Kubernetes. It begins with a quick Apache Camel demo of a Twitter search application built with Camel. It then provides an overview of Kubernetes and fabric8, including key concepts like pods, replication controllers, services, and labels. The remainder discusses developing and deploying Java microservices to Kubernetes using Camel, CDI, fabric8, and the OpenShift CLI for tasks like deployment, scaling, and viewing logs.
Vagrant allows users to define and manage virtual machine environments in code. It provides tools to easily create consistent development environments that match production. With Vagrant, users can define virtual machines and provision them automatically using tools like Chef, Puppet, or shell scripts. This allows development environments to match production and avoids issues caused by differences between environments. Vagrant saves time by automating environment setup and ensuring environments are consistent.
Fabric8 - Being devOps doesn't suck anymoreHenryk Konsek
Fabric8 is a tool that aims to reduce the gap between development and operations by allowing developers to deploy and manage applications from development through production. It uses profiles and containers to deploy applications in a unified way across environments. Fabric8 supports various containers like Tomcat, Docker, and OpenShift. It includes integrated monitoring via Hawt.io and a shell to help with scripting and diagnostics. The goal is to make developers more self-sufficient by enabling them to take on more operations tasks in their own sandboxes.
This document discusses using Vagrant and configuration management tools like Puppet and Chef to create lightweight reproducible development environments. It provides an overview of virtualization and tools like Vagrant, Puppet and Chef. It demonstrates how to use these tools to automate the creation of virtual machines and configure them. It also summarizes the Vagrant-Binding Java library that allows managing Vagrant environments programmatically.
5 steps to take setting up a streamlined container pipelineMichel Schildmeijer
The document outlines 5 steps to set up a container pipeline:
1. Use versioning and container registries like GitHub, Docker, and private registries to manage code versions and container images.
2. Use an orchestration engine like Kubernetes to manage and orchestrate container processes. Common options are AWS EKS, GCP GKE, and Oracle OKE.
3. Provision the Kubernetes cluster using scripts or Terraform on cloud infrastructure like OCI.
4. Implement container pipelines using tools like Oracle Container Pipelines to automate building, testing, and deploying containers.
5. Use Helm to package and deploy Kubernetes applications and integrate it into the CI/CD pipeline
https://jeeconf.com/program/containerising-bootiful-microservices/
Presentation on how we implemented Kubernetes and Jenkins to deploy and keep running Spring Cloud Netflix based microservices in private cloud.
Overview of decision made about technology stack, testing strategy, tools and infrastructure components, continuous delivery/deployment pipelines and some implementation details and issues met.
ASP.NET 5 is open source and cross-platform, allowing .NET applications to run on Windows, Linux, and OS X. It features a modular architecture and tools like KVM, KRE, and KPM for managing versions and running ASP.NET apps. Developers can use Mono on OS X along with plugins for editors like Sublime Text. JavaScript tools like Grunt and Bower are also discussed for managing dependencies and tasks. The document demonstrates deploying .NET applications to Linux using Visual Studio and Docker.
An overview on docker and container technology behind it. Lastly, we discuss few tools that might come handy when dealing with large number of containers management.
This document provides an overview of DevOPS concepts including containers, Docker, and related tools. It discusses what containers are and the differences between virtual machines and containers. It then covers how containers can be used by developers and systems engineers. Docker is introduced as a tool for running and managing containers. Dockerfiles are described as documents for assembling container images. Docker Compose is presented as a tool for defining and running multi-container applications. Examples are given for creating a simple container with Dockerfile and running it locally and sharing it publicly. Monitoring tools like cAdvisor are mentioned. The document ends with discussing continuous integration/deployment using tools like Gitlab and Jenkins to automate the build and deployment process.
Build and Deploy Cloud Native Camel Quarkus routes with Tekton and KnativeOmar Al-Safi
In this talk, we will leverage all cloud native stacks and tools to build Camel Quarkus routes natively using GraalVM native-image on Tekton pipeline and deploy these routes to Kubernetes cluster with Knative installed. We will dive into the following topics in the talk: - Introduction to Camel - Introduction to Camel Quarkus - Introduction to GraalVM Native Image - Introduction to Tekon - Introduction to Knative - Demo shows how to deploy end to end a Camel Quarkus route which include the following steps: - Look at whole deployment pipeline for Cloud Native Camel Quarkus routes - Build Camel Quarkus routes with GraalVM native-image on Tekton pipeline. - Deploy Camel Quarkus routes to Kubernetes cluster with Knative Targeted Audience: Users with basic Camel knowledge
Presentation given to the UK WebSphere User Group on 24 April 2016 giving a recap and update on integration between WebSphere Application Server and Docker. It covers both Liberty and the traditional application server.
When to use Serverless? When to use Kubernetes?Niklas Heidloff
Slides of a session that I have given/will give at various developer conferences in H1 2018.
Niklas Heidloff
http://twitter.com/nheidloff
http://heidloff.net
Summary Article
http://heidloff.net/article/when-to-use-serverless-kubernetes
OpenWhisk
https://openwhisk.apache.org
https://github.com/ibm-functions/composer
https://github.com/nheidloff/openwhisk-debug-nodejs
Kubernetes
https://kubernetes.io
https://istio.io
IBM Cloud
http://ibm.biz/nheidloff
Abstract
There is a lot of debate whether to use Serverless or Kubernetes to build cloud-native apps. Both have their advantages and unique capabilities which developers should take into consideration when planning new projects. We will throw some light on the topics ease of use, maturity, types of scenarios, developer productivity and debugging, supported languages, DevOps and monitoring, performance, community and pricing. Cloud-native architectures shift the complexity from within an application to orchestrations of Microservices. Both Kubernetes and Serverless have their strengths which we will discuss. Besides the core development topics, developers should also understand operational aspects how complicated it is to maintain your own systems versus using managed platforms.
The path to a serverless-native era with Kubernetessparkfabrik
In this talk we'll talk about how the Serverless paradigms are changing the way we develop applications and cloud infrastructure and how we can implement them in a
efficient and seamless way with Kubernetes.
We'll go through the latest Kubernetes Serverless technologies, talking about all the aspects
including pricing, scalability, observability and best practices.
Serverless Munich Meetup, Juli 2019, Munich: Talk by Mario-Leander Reimer (@LeanderReimer, Principal Software Architect at QAware)
=== Please download slides if blurred! ===
Abstract: Not long ago, the advent of microservice architectures was a big disruption in software engineering: systems were now build, composed and run as autonomous services. But this came at the price of added complexity. Serverless and FaaS seem to be the next disruption, they are the logical evolution in cloud native software development.
Of course, FaaS bringt its own set of challenges, such as cold startup performance, asynchronism and overall throughput. But it does not have to be all that bad. Do you want to know what real fast FaaS looks like? Then fasten your seatbelts when we give Nuclio a try.
stackconf 2020 | The path to a Serverless-native era with Kubernetes by Paolo...NETWAYS
Serverless is one of the hottest design patterns in the cloud today, i’ll cover how the Serverless paradigms are changing the way we develop applications and the cloud infrastructures and how to implement Serveless-kind workloads with Kubernetes.
We’ll go through the latest Kubernetes-based serverless technologies, covering the most important aspects including pricing, scalability, observability and best practices
Telepresence allows developers to test applications locally that are deployed to Kubernetes clusters. It creates a network proxy between a local development environment and a pod running in the cluster, enabling local development and testing that reflects the cluster environment. Key features include deploying and debugging services locally without changing code in the cluster. The document provides an overview of Telepresence and examples for installing it and using it to swap a deployment for local development of both a Python HTTP server and Docker container-based application.
Kubernetes is a great tool to run (Docker) containers in a clustered production environment. When deploying often to production we need fully automated blue-green deployments, which makes it possible to deploy without any downtime. We also need to handle external HTTP requests and SSL offloading. This requires integration with a load balancer like Ha-Proxy. Another concern is (semi) auto scaling of the Kubernetes cluster itself when running in a cloud environment. E.g. partially scale down the cluster at night.
In this technical deep dive you will learn how to setup Kubernetes together with other open source components to achieve a production ready environment that takes code from git commit to production without downtime.
Similar to Developing Microservices with Apache Camel, by Claus Ibsen (20)
The document discusses foundational technologies for data-driven businesses. It describes how data is growing exponentially and outlines challenges in using data due to issues like inconsistency, duplication, and size. It then presents an intelligent data lifecycle framework involving ingesting, interpreting, and transforming data. Key foundational technologies are discussed like messaging systems, data virtualization, rules engines, machine learning, business process management, and robotic process automation. An anti-money laundering use case is presented using these technologies in an open system architecture.
Agile integration activation: get hands on with ap-isJudy Breedlove
This document discusses agile integration and APIs. It covers various use cases for events, data, and enterprise integration patterns. It also discusses API management foundations like controlling access, visibility, and flexibility. The remainder of the document focuses on the API lifecycle from design to implementation to operation. It provides examples of tools that can be used for API design, implementation, testing, deployment and management. Finally, it outlines hands-on tasks for setting up a database, designing an API, implementing and publishing an integration, testing, deploying, securing and consuming an API.
Preparing your organization for microservicesJudy Breedlove
This document discusses preparing an organization for microservices by embracing change. It addresses where an organization currently stands with change and digital transformation, noting that change is complex and far-reaching. It discusses organizing teams around microservices and defining new roles. The document also covers leveraging technology, improving processes through DevOps, and taking incremental steps to implement foundational changes that will transform the organization.
An API-focused approach to Agile IntegrationJudy Breedlove
This document discusses an API-focused approach for agile integration. It advocates designing APIs with clients in mind, validating designs early through mocking or skeleton implementations, and favoring interoperability. The document also outlines an agile integration architecture with core, composite and application network layers and describes how containers, hybrid environments, automation, control, visibility and flexibility are important. It encourages attendees to try out the Red Hat Integration platform themselves.
Introduction to red hat agile integration (Red Hat Workshop)Judy Breedlove
This presentation provides and overview of Red Hat's approached to Agile integration. It was presented at the "Agile integration with Containers & APIs" workshop series. Fall 2018
An API-focused approach to Agile IntegrationJudy Breedlove
This document discusses an API-focused approach to agile integration. It outlines different integration patterns like point-to-point, service bus, and microservices. Key drivers for agile integration are technical factors like cloud adoption, microservices, and APIs as well as strategic and business factors. The document advocates for a distributed and flexible integration approach using containers and APIs to connect internal and external systems and enable self-service integration.
This document provides an overview of a hands-on technical workshop on transforming monolithic applications to microservices. The workshop will cover industry trends in application development, Red Hat's approach to application modernization, migrating existing Java EE applications to Red Hat OpenShift, developing microservices using frameworks like Spring Boot and deploying using OpenShift and DevOps processes. Attendees will learn how to discuss migration strategies with customers, develop reactive microservices, package microservices, and prevent and detect issues in distributed systems. The all-day workshop includes sessions on moving existing apps to the cloud, developing on OpenShift, monolith to microservices migration, reactive microservices, and packaging and detecting issues in microservices applications.
Evolution of integration and microservices patterns with service meshJudy Breedlove
The document discusses the evolution of integration and microservice patterns with service mesh technologies like Istio. It describes how service meshes provide decentralized application networking infrastructure between services through a data plane and control plane. This includes features like advanced load balancing, traffic control, observability, and policy enforcement that help improve resilience, security, and reliability of distributed applications.
The Future of Cloud Native Apps - Chicago IntroJudy Breedlove
The document summarizes three waves of change happening in the Midwest: changing builds towards cloud-native applications, changing integration styles with microservices and service meshes, and changing compute models with serverless functions. It then provides details of an upcoming event hosted at innovation space 1871 in Chicago, featuring talks on cloud-native applications, microservices, and serverless functions. The document concludes with a list of upcoming Red Hat events in the Midwest focusing on OpenShift, Ansible, containers, and cloud-native technologies.
Serverless and serverfull - where microservices compliments serverlessJudy Breedlove
The document discusses the relationship between serverless and microservices architectures. It provides links to resources for learning about microservices, serverless functions, Istio, and OpenWhisk. Short snippets of code demonstrate how to write actions for OpenWhisk in JavaScript, Python, and Java. The document advocates leveraging third-party services (BaaS) and custom code run in containers (FaaS) to build serverless applications, while microservices can also be integrated through long-running containers and functions.
Agile integration: Decomposing the monolith Judy Breedlove
This document discusses strategies for decomposing monolithic applications into microservices and ensuring resilience of the resulting microservices architecture. It covers decomposing monoliths using API-first and single responsibility principles. Managing the complex microservices architecture requires approaches for cross-cutting concerns like fault tolerance, traffic management, policy enforcement, distributed tracing, and infrastructure concerns like circuit breaking. A service mesh like Istio deployed as sidecars can provide a communications control plane for traffic management, policy enforcement, and distributed tracing between microservices.
Orca: Nocode Graphical Editor for Container OrchestrationPedro J. Molina
Tool demo on CEDI/SISTEDES/JISBD2024 at A Coruña, Spain. 2024.06.18
"Orca: Nocode Graphical Editor for Container Orchestration"
by Pedro J. Molina PhD. from Metadev
Photoshop Tutorial for Beginners (2024 Edition)alowpalsadig
Photoshop Tutorial for Beginners (2024 Edition)
Explore the evolution of programming and software development and design in 2024. Discover emerging trends shaping the future of coding in our insightful analysis."
Here's an overview:Introduction: The Evolution of Programming and Software DevelopmentThe Rise of Artificial Intelligence and Machine Learning in CodingAdopting Low-Code and No-Code PlatformsQuantum Computing: Entering the Software Development MainstreamIntegration of DevOps with Machine Learning: MLOpsAdvancements in Cybersecurity PracticesThe Growth of Edge ComputingEmerging Programming Languages and FrameworksSoftware Development Ethics and AI RegulationSustainability in Software EngineeringThe Future Workforce: Remote and Distributed TeamsConclusion: Adapting to the Changing Software Development LandscapeIntroduction: The Evolution of Programming and Software Development
Photoshop Tutorial for Beginners (2024 Edition)Explore the evolution of programming and software development and design in 2024. Discover emerging trends shaping the future of coding in our insightful analysis."Here's an overview:Introduction: The Evolution of Programming and Software DevelopmentThe Rise of Artificial Intelligence and Machine Learning in CodingAdopting Low-Code and No-Code PlatformsQuantum Computing: Entering the Software Development MainstreamIntegration of DevOps with Machine Learning: MLOpsAdvancements in Cybersecurity PracticesThe Growth of Edge ComputingEmerging Programming Languages and FrameworksSoftware Development Ethics and AI RegulationSustainability in Software EngineeringThe Future Workforce: Remote and Distributed TeamsConclusion: Adapting to the Changing Software Development LandscapeIntroduction: The Evolution of Programming and Software Development
The importance of developing and designing programming in 2024
Programming design and development represents a vital step in keeping pace with technological advancements and meeting ever-changing market needs. This course is intended for anyone who wants to understand the fundamental importance of software development and design, whether you are a beginner or a professional seeking to update your knowledge.
Course objectives:
1. **Learn about the basics of software development:
- Understanding software development processes and tools.
- Identify the role of programmers and designers in software projects.
2. Understanding the software design process:
- Learn about the principles of good software design.
- Discussing common design patterns such as Object-Oriented Design.
3. The importance of user experience (UX) in modern software:
- Explore how user experience can improve software acceptance and usability.
- Tools and techniques to analyze and improve user experience.
4. Increase efficiency and productivity through modern development tools:
- Access to the latest programming tools and languages used in the industry.
- Study live examples of applications
How Can Hiring A Mobile App Development Company Help Your Business Grow?ToXSL Technologies
ToXSL Technologies is an award-winning Mobile App Development Company in Dubai that helps businesses reshape their digital possibilities with custom app services. As a top app development company in Dubai, we offer highly engaging iOS & Android app solutions. https://rb.gy/necdnt
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
DevOps Consulting Company | Hire DevOps Servicesseospiralmantra
Spiral Mantra excels in providing comprehensive DevOps services, including Azure and AWS DevOps solutions. As a top DevOps consulting company, we offer controlled services, cloud DevOps, and expert consulting nationwide, including Houston and New York. Our skilled DevOps engineers ensure seamless integration and optimized operations for your business. Choose Spiral Mantra for superior DevOps services.
https://www.spiralmantra.com/devops/
The Comprehensive Guide to Validating Audio-Visual Performances.pdfkalichargn70th171
Ensuring the optimal performance of your audio-visual (AV) equipment is crucial for delivering exceptional experiences. AV performance validation is a critical process that verifies the quality and functionality of your AV setup. Whether you're a content creator, a business conducting webinars, or a homeowner creating a home theater, validating your AV performance is essential.
Alluxio Webinar | 10x Faster Trino Queries on Your Data PlatformAlluxio, Inc.
Alluxio Webinar
June. 18, 2024
For more Alluxio Events: https://www.alluxio.io/events/
Speaker:
- Jianjian Xie (Staff Software Engineer, Alluxio)
As Trino users increasingly rely on cloud object storage for retrieving data, speed and cloud cost have become major challenges. The separation of compute and storage creates latency challenges when querying datasets; scanning data between storage and compute tiers becomes I/O bound. On the other hand, cloud API costs related to GET/LIST operations and cross-region data transfer add up quickly.
The newly introduced Trino file system cache by Alluxio aims to overcome the above challenges. In this session, Jianjian will dive into Trino data caching strategies, the latest test results, and discuss the multi-level caching architecture. This architecture makes Trino 10x faster for data lakes of any scale, from GB to EB.
What you will learn:
- Challenges relating to the speed and costs of running Trino in the cloud
- The new Trino file system cache feature overview, including the latest development status and test results
- A multi-level cache framework for maximized speed, including Trino file system cache and Alluxio distributed cache
- Real-world cases, including a large online payment firm and a top ridesharing company
- The future roadmap of Trino file system cache and Trino-Alluxio integration
Transforming Product Development using OnePlan To Boost Efficiency and Innova...OnePlan Solutions
Ready to overcome challenges and drive innovation in your organization? Join us in our upcoming webinar where we discuss how to combat resource limitations, scope creep, and the difficulties of aligning your projects with strategic goals. Discover how OnePlan can revolutionize your product development processes, helping your team to innovate faster, manage resources more effectively, and deliver exceptional results.
Boost Your Savings with These Money Management AppsJhone kinadey
A money management app can transform your financial life by tracking expenses, creating budgets, and setting financial goals. These apps offer features like real-time expense tracking, bill reminders, and personalized insights to help you save and manage money effectively. With a user-friendly interface, they simplify financial planning, making it easier to stay on top of your finances and achieve long-term financial stability.
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
Enhanced Screen Flows UI/UX using SLDS with Tom KittPeter Caitens
Join us for an engaging session led by Flow Champion, Tom Kitt. This session will dive into a technique of enhancing the user interfaces and user experiences within Screen Flows using the Salesforce Lightning Design System (SLDS). This technique uses Native functionality, with No Apex Code, No Custom Components and No Managed Packages required.
A neural network is a machine learning program, or model, that makes decisions in a manner similar to the human brain, by using processes that mimic the way biological neurons work together to identify phenomena, weigh options and arrive at conclusions.
WWDC 2024 Keynote Review: For CocoaCoders AustinPatrick Weigel
Overview of WWDC 2024 Keynote Address.
Covers: Apple Intelligence, iOS18, macOS Sequoia, iPadOS, watchOS, visionOS, and Apple TV+.
Understandable dialogue on Apple TV+
On-device app controlling AI.
Access to ChatGPT with a guest appearance by Chief Data Thief Sam Altman!
App Locking! iPhone Mirroring! And a Calculator!!
DECODING JAVA THREAD DUMPS: MASTER THE ART OF ANALYSISTier1 app
Are you ready to unlock the secrets hidden within Java thread dumps? Join us for a hands-on session where we'll delve into effective troubleshooting patterns to swiftly identify the root causes of production problems. Discover the right tools, techniques, and best practices while exploring *real-world case studies of major outages* in Fortune 500 enterprises. Engage in interactive lab exercises where you'll have the opportunity to troubleshoot thread dumps and uncover performance issues firsthand. Join us and become a master of Java thread dump analysis!
3. Claus Ibsen
• Principal Software Engineer
at Red Hat
• Apache Camel
8 years working with Camel
• Author of
Camel in Action books
@davsclaus
davsclaus
davsclaus.com
28. Our Demo
Client Hello Service
http://localhost:8080
from timer
to http
log
from undertow
transform
helloservice
29. Static vs Dynamic Platform
Client Hello Service
from timer
to http
log
from undertow
transform
helloservice
Hardcoded
hostname and port
http://localhost:8080
38. Using Kubernetes
Service
• Environment Variables
• Hostname
• Port
Client
from timer
to http
log
Service Discovery using DNS is available
in newer versions of Kubernetes.