In this session, we will explore key challenges with function interactions and coordination, addressing these problems using Enterprise Integration Patterns (EIP) and modern approaches with the latest innovations from the Apache Camel community:
Apache Camel is the Swiss army knife of integration, and the most powerful integration framework. In this session you will hear about the latest features in the brand new 3rd generation.
Camel K, is a lightweight integration platform that enables Enterprise Integration Patterns to be used natively on any Kubernetes cluster. When used in combination with Knative, a framework that adds serverless building blocks to Kubernetes, and the subatomic execution environment of Quarkus, Camel K can mix serverless features such as auto-scaling, scaling to zero, and event-based communication with the outstanding integration capabilities of Apache Camel.
- Apache Camel 3
- Camel K
- Camel Quarkus
We will show how Camel K works. We’ll also use examples to demonstrate how Camel K makes it easier to connect to cloud services or enterprise applications using some of the 300 components that Camel provides.
Integrating systems in the age of Quarkus and CamelClaus Ibsen
Apache Camel has been the Swiss knife of integrating heterogeneous systems for more than a decade. Claus Ibsen explains how Camel adapts to the newest changes with microservices and cloud computing! Apache Camel integrations written on top of Quarkus start in a matter of milliseconds and consume just a few tens of megabytes of RAM. We will explain the technology and show a demo including the famous Quarkus dev mode. Then you will learn how the outstanding integration capabilities of Apache Camel enrich the serverless architectures based on Knative and CamelK!
Integrating microservices with apache camel on kubernetesClaus Ibsen
Apache Camel has fundamentally changed the way Java developers build system-to-system integrations by using enterprise integration patterns (EIP) with modern microservice architectures. In this session, we’ll show you best practices with Camel and EIPs, in the world of Spring Boot microservices running on Kubernetes. We'll also discuss practices how to build truly cloud-native distributed and fault-tolerant microservices and we’ll introduce the upcoming Camel 3.0 release, which includes serverless capabilities via Camel K. This talk is a mix with slides and live demos.
Best Practices for Middleware and Integration Architecture Modernization with...Claus Ibsen
This document discusses best practices for middleware and integration architecture modernization using Apache Camel. It provides an overview of Apache Camel, including what it is, how it works through routes, and the different Camel projects. It then covers trends in integration architecture like microservices, cloud native, and serverless. Key aspects of Camel K and Camel Quarkus are summarized. The document concludes with a brief discussion of the Camel Kafka Connector and pointers to additional resources.
Serverless integration with Knative and Apache Camel on KubernetesClaus Ibsen
This presentation will introduce Knative, an open source project that adds serverless capabilities on top of Kubernetes, and present Camel K, a lightweight platform that brings Apache Camel integrations in the serverless world. Camel K allows running Camel routes on top of any Kubernetes cluster, leveraging Knative serverless capabilities such as “scaling to zero”.
We will demo how Camel K can connect cloud services or enterprise applications using its 250+ components and how it can intelligently route events within the Knative environment via enterprise integration patterns (EIP).
Target Group: Developers, architects and other technical people - a basic understanding of Kubernetes is an advantage
2 hour session where I cover what is Apache Camel, latest news on the upcoming Camel v3, and then the main topic of the talk is the new Camel K sub-project for running integrations natively on the cloud with kubernetes. The last part of the talk is about running Camel with GraalVM / Quarkus to archive native compiled binaries that has impressive startup and footprint.
VMware is introducing new platforms to better support cloud-native applications, including containers. The Photon Platform is a lightweight, API-driven control plane optimized for massive scale container deployments. It includes Photon OS, a lightweight Linux distribution for containers. vSphere Integrated Containers allows running containers alongside VMs on vSphere infrastructure for a unified hybrid approach. Both aim to provide the portability and agility of containers while leveraging VMware's management capabilities.
Service Mesh @Lara Camp Myanmar - 02 Sep,2023Hello Cloud
Sai Linnthu is a founding partner at HelloCloud.io and discusses service meshes and Istio. Istio provides a framework-agnostic approach for managing communication policies and observability across cloud-native microservices. While Istio addresses many challenges of microservices, its complexity makes it difficult to use and manage across multiple clouds without additional capabilities like centralized metrics, access logging and lifecycle management.
Integrating systems in the age of Quarkus and CamelClaus Ibsen
Apache Camel has been the Swiss knife of integrating heterogeneous systems for more than a decade. Claus Ibsen explains how Camel adapts to the newest changes with microservices and cloud computing! Apache Camel integrations written on top of Quarkus start in a matter of milliseconds and consume just a few tens of megabytes of RAM. We will explain the technology and show a demo including the famous Quarkus dev mode. Then you will learn how the outstanding integration capabilities of Apache Camel enrich the serverless architectures based on Knative and CamelK!
Integrating microservices with apache camel on kubernetesClaus Ibsen
Apache Camel has fundamentally changed the way Java developers build system-to-system integrations by using enterprise integration patterns (EIP) with modern microservice architectures. In this session, we’ll show you best practices with Camel and EIPs, in the world of Spring Boot microservices running on Kubernetes. We'll also discuss practices how to build truly cloud-native distributed and fault-tolerant microservices and we’ll introduce the upcoming Camel 3.0 release, which includes serverless capabilities via Camel K. This talk is a mix with slides and live demos.
Best Practices for Middleware and Integration Architecture Modernization with...Claus Ibsen
This document discusses best practices for middleware and integration architecture modernization using Apache Camel. It provides an overview of Apache Camel, including what it is, how it works through routes, and the different Camel projects. It then covers trends in integration architecture like microservices, cloud native, and serverless. Key aspects of Camel K and Camel Quarkus are summarized. The document concludes with a brief discussion of the Camel Kafka Connector and pointers to additional resources.
Serverless integration with Knative and Apache Camel on KubernetesClaus Ibsen
This presentation will introduce Knative, an open source project that adds serverless capabilities on top of Kubernetes, and present Camel K, a lightweight platform that brings Apache Camel integrations in the serverless world. Camel K allows running Camel routes on top of any Kubernetes cluster, leveraging Knative serverless capabilities such as “scaling to zero”.
We will demo how Camel K can connect cloud services or enterprise applications using its 250+ components and how it can intelligently route events within the Knative environment via enterprise integration patterns (EIP).
Target Group: Developers, architects and other technical people - a basic understanding of Kubernetes is an advantage
2 hour session where I cover what is Apache Camel, latest news on the upcoming Camel v3, and then the main topic of the talk is the new Camel K sub-project for running integrations natively on the cloud with kubernetes. The last part of the talk is about running Camel with GraalVM / Quarkus to archive native compiled binaries that has impressive startup and footprint.
VMware is introducing new platforms to better support cloud-native applications, including containers. The Photon Platform is a lightweight, API-driven control plane optimized for massive scale container deployments. It includes Photon OS, a lightweight Linux distribution for containers. vSphere Integrated Containers allows running containers alongside VMs on vSphere infrastructure for a unified hybrid approach. Both aim to provide the portability and agility of containers while leveraging VMware's management capabilities.
Service Mesh @Lara Camp Myanmar - 02 Sep,2023Hello Cloud
Sai Linnthu is a founding partner at HelloCloud.io and discusses service meshes and Istio. Istio provides a framework-agnostic approach for managing communication policies and observability across cloud-native microservices. While Istio addresses many challenges of microservices, its complexity makes it difficult to use and manage across multiple clouds without additional capabilities like centralized metrics, access logging and lifecycle management.
Getting Started with Apache Spark on KubernetesDatabricks
Community adoption of Kubernetes (instead of YARN) as a scheduler for Apache Spark has been accelerating since the major improvements from Spark 3.0 release. Companies choose to run Spark on Kubernetes to use a single cloud-agnostic technology across their entire stack, and to benefit from improved isolation and resource sharing for concurrent workloads. In this talk, the founders of Data Mechanics, a serverless Spark platform powered by Kubernetes, will show how to easily get started with Spark on Kubernetes.
This document provides an overview of Kubernetes including:
1) Kubernetes is an open-source platform for automating deployment, scaling, and operations of containerized applications. It provides container-centric infrastructure and allows for quickly deploying and scaling applications.
2) The main components of Kubernetes include Pods (groups of containers), Services (abstract access to pods), ReplicationControllers (maintain pod replicas), and a master node running key components like etcd, API server, scheduler, and controller manager.
3) The document demonstrates getting started with Kubernetes by enabling the master on one node and a worker on another node, then deploying and exposing a sample nginx application across the cluster.
Cloud-Native Integration with Apache Camel on Kubernetes (Copenhagen October ...Claus Ibsen
Camel K is a lightweight integration platform based on Apache Camel that is optimized to run on Kubernetes and Knative. It allows developers to write integration logic using the Apache Camel Domain Specific Language and deploy it to Kubernetes with a single command. Camel K runs the integration as microservices on Kubernetes and handles scaling and management of the integration runtime. It aims to provide a serverless experience for building and running integrations in cloud-native environments.
Docker Kubernetes Istio
Understanding Docker and creating containers.
Container Orchestration based on Kubernetes
Blue Green Deployment, AB Testing, Canary Deployment, Traffic Rules based on Istio
This document provides an overview of the Red Hat Ansible Automation Platform. It begins with discussing why automation is important, citing industry analysts and research showing that automation is a strategic priority. It then discusses why the Red Hat Ansible platform specifically, noting its leadership position in Forrester evaluations. The rest of the document discusses what makes a platform, covering the key elements of creating, operating, and consuming automation. It details the various components of the Ansible platform that address the automation lifecycle.
Kubernetes Application Deployment with Helm - A beginner Guide!Krishna-Kumar
Google DevFest2019 Presentation at Infosys Campus Bangalore. Application deployment in Kubernetes with Helm is demo'ed in Google Kubernetes Engine (GKE). This is an introductory session on Helm. Several references are given in it to further explore helm3 as it is in Beta state now.
Helm version 3 was recently released with new features and a new architecture to support those features. The changes to Helm and charts were based on feedback, changes to Kubernetes, and lessons learned in the past couple years.
Terraform is a tool for building, changing, and version controlling infrastructure safely and efficiently. It allows users to define and provision resources through code rather than manual configuration. Key concepts include variables, outputs, providers that interface with cloud platforms, reusable modules, and managing infrastructure through commands like plan, apply, and destroy. The presentation demonstrated Terraform's capabilities with a live demo and provided additional resources for learning more.
2 hour session where I cover what is Apache Camel, latest news on the upcoming Camel v3, and then the main topic of the talk is the new Camel K sub-project for running integrations natively on the cloud with kubernetes. The last part of the talk is about running Camel with GraalVM / Quarkus to archive native compiled binaries that has impressive startup and footprint.
Camel Day Italy 2021 - What's new in Camel 3Claus Ibsen
Slides for the 50 min presentation at Camel Day Italy 2021, where Claus Ibsen and Andrea Cosentino had the opporunity to give a more deep dive talk about the journey towards Camel 3, and what we have done to re-architect camel core in v3 to make it awesome for microservices, cloud native, kubernetes, quarkus, graalvm, knative, apache kafka.
Camel Day Italy 2021: https://www.meetup.com/it-IT/red-hat-developers-italy/events/275332376/
This document introduces infrastructure as code (IaC) using Terraform and provides examples of deploying infrastructure on AWS including:
- A single EC2 instance
- A single web server
- A cluster of web servers using an Auto Scaling Group
- Adding a load balancer using an Elastic Load Balancer
It also discusses Terraform concepts and syntax like variables, resources, outputs, and interpolation. The target audience is people who deploy infrastructure on AWS or other clouds.
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.
Nicola Ferraro and Luca Burgazzoli presented on Apache Camel K, a lightweight integration platform for running integrations on Kubernetes. Camel K allows developers to write integration logic in a simple DSL and have it run as serverless functions on Kubernetes. It integrates well with Knative for auto-scaling and can connect to over 300 components. The presentation demonstrated Camel K's use in a event mesh and discussed current developments including support for Quarkus, Kamelets for reusable integration snippets, and testing with YAKS. Camel K aims to simplify building integrations in a cloud native environment.
Helm - Application deployment management for KubernetesAlexei Ledenev
Use Helm to package and deploy a composed application to any Kubernetes cluster. Manage your releases easily over time and across multiple K8s clusters.
This document provides an overview of microservices architecture, including concepts, characteristics, infrastructure patterns, and software design patterns relevant to microservices. It discusses when microservices should be used versus monolithic architectures, considerations for sizing microservices, and examples of pioneers in microservices implementation like Netflix and Spotify. The document also covers domain-driven design concepts like bounded context that are useful for decomposing monolithic applications into microservices.
Kubernetes Helm makes application deployment easy, standardized and reusable. Use of Kubernetes Helm leads to better developer productivity, reduced Kubernetes deployment complexity and enhanced enterprise production readiness.
Enterprises using Kubernetes Helm can speed up the adoption of cloud native applications. These applications can be sourced from open-source community provided repositories, or from an organization’s internal repository of customized application blueprints.
Developers can use Kubernetes Helm as a vehicle for packaging their applications and sharing them with the Kubernetes community. Kubernetes Helm also allows software vendors to offer their containerized applications at “the push of a button.” Through a single command or a few mouse clicks, users can install Kubernetes apps for dev-test or production environments.
The document provides an overview of Terraform, including that it is a declarative provisioning tool that uses HCL or JSON to safely evolve infrastructure in a predictable way. It discusses Terraform's use of graph theory to identify dependencies, its plugin-based architecture to compose multiple cloud services, and its core concepts like providers, resources, data sources, and the workflow of plan, apply, and destroy.
This document provides an overview of cloud native concepts including:
- Cloud native is defined as applications optimized for modern distributed systems capable of scaling to thousands of nodes.
- The pillars of cloud native include devops, continuous delivery, microservices, and containers.
- Common use cases for cloud native include development, operations, legacy application refactoring, migration to cloud, and building new microservice applications.
- While cloud native adoption is growing, challenges include complexity, cultural changes, lack of training, security concerns, and monitoring difficulties.
State of integration with Apache Camel (ApacheCon 2019)Claus Ibsen
Apache Camel is the leading open source integration framework, which has been around for over a decade. In this talk we will look back in history, to understand how the integration landscape has evolved from EAI, SOA, and ESB architectures up to microservices, and now with modern serverless and cloud native platforms. Apache Camel has been along for the ride. And we will look to the future and see how the latest release v3 of Apache Camel, is aimed for running modern cloud native workloads with Camel K. In this talk you will: Learn from history software integration, and why you should rely on existing, proven fully featured integration frameworks instead of rolling out your own DIY solutions. See how software integration is (still) important in today’s modern architectures and what role does Camel have in the new cloud native world. What is new and noteworthy in Apache Camel version 3
Camel K allows building and deploying Apache Camel integration applications on Kubernetes in about 1 second. It provides a lightweight runtime for Camel on Kubernetes that enables low-code/no-code integration using Camel's Java DSL. Camel K applications can take advantage of serverless capabilities provided by Knative like autoscaling and scaling to zero. Quarkus is a Kubernetes-native Java stack that provides a minimal footprint and container-first experience for building microservices. It works well with Camel/Camel K by enabling native compilation of Camel routes for very fast startup times and low memory usage.
Getting Started with Apache Spark on KubernetesDatabricks
Community adoption of Kubernetes (instead of YARN) as a scheduler for Apache Spark has been accelerating since the major improvements from Spark 3.0 release. Companies choose to run Spark on Kubernetes to use a single cloud-agnostic technology across their entire stack, and to benefit from improved isolation and resource sharing for concurrent workloads. In this talk, the founders of Data Mechanics, a serverless Spark platform powered by Kubernetes, will show how to easily get started with Spark on Kubernetes.
This document provides an overview of Kubernetes including:
1) Kubernetes is an open-source platform for automating deployment, scaling, and operations of containerized applications. It provides container-centric infrastructure and allows for quickly deploying and scaling applications.
2) The main components of Kubernetes include Pods (groups of containers), Services (abstract access to pods), ReplicationControllers (maintain pod replicas), and a master node running key components like etcd, API server, scheduler, and controller manager.
3) The document demonstrates getting started with Kubernetes by enabling the master on one node and a worker on another node, then deploying and exposing a sample nginx application across the cluster.
Cloud-Native Integration with Apache Camel on Kubernetes (Copenhagen October ...Claus Ibsen
Camel K is a lightweight integration platform based on Apache Camel that is optimized to run on Kubernetes and Knative. It allows developers to write integration logic using the Apache Camel Domain Specific Language and deploy it to Kubernetes with a single command. Camel K runs the integration as microservices on Kubernetes and handles scaling and management of the integration runtime. It aims to provide a serverless experience for building and running integrations in cloud-native environments.
Docker Kubernetes Istio
Understanding Docker and creating containers.
Container Orchestration based on Kubernetes
Blue Green Deployment, AB Testing, Canary Deployment, Traffic Rules based on Istio
This document provides an overview of the Red Hat Ansible Automation Platform. It begins with discussing why automation is important, citing industry analysts and research showing that automation is a strategic priority. It then discusses why the Red Hat Ansible platform specifically, noting its leadership position in Forrester evaluations. The rest of the document discusses what makes a platform, covering the key elements of creating, operating, and consuming automation. It details the various components of the Ansible platform that address the automation lifecycle.
Kubernetes Application Deployment with Helm - A beginner Guide!Krishna-Kumar
Google DevFest2019 Presentation at Infosys Campus Bangalore. Application deployment in Kubernetes with Helm is demo'ed in Google Kubernetes Engine (GKE). This is an introductory session on Helm. Several references are given in it to further explore helm3 as it is in Beta state now.
Helm version 3 was recently released with new features and a new architecture to support those features. The changes to Helm and charts were based on feedback, changes to Kubernetes, and lessons learned in the past couple years.
Terraform is a tool for building, changing, and version controlling infrastructure safely and efficiently. It allows users to define and provision resources through code rather than manual configuration. Key concepts include variables, outputs, providers that interface with cloud platforms, reusable modules, and managing infrastructure through commands like plan, apply, and destroy. The presentation demonstrated Terraform's capabilities with a live demo and provided additional resources for learning more.
2 hour session where I cover what is Apache Camel, latest news on the upcoming Camel v3, and then the main topic of the talk is the new Camel K sub-project for running integrations natively on the cloud with kubernetes. The last part of the talk is about running Camel with GraalVM / Quarkus to archive native compiled binaries that has impressive startup and footprint.
Camel Day Italy 2021 - What's new in Camel 3Claus Ibsen
Slides for the 50 min presentation at Camel Day Italy 2021, where Claus Ibsen and Andrea Cosentino had the opporunity to give a more deep dive talk about the journey towards Camel 3, and what we have done to re-architect camel core in v3 to make it awesome for microservices, cloud native, kubernetes, quarkus, graalvm, knative, apache kafka.
Camel Day Italy 2021: https://www.meetup.com/it-IT/red-hat-developers-italy/events/275332376/
This document introduces infrastructure as code (IaC) using Terraform and provides examples of deploying infrastructure on AWS including:
- A single EC2 instance
- A single web server
- A cluster of web servers using an Auto Scaling Group
- Adding a load balancer using an Elastic Load Balancer
It also discusses Terraform concepts and syntax like variables, resources, outputs, and interpolation. The target audience is people who deploy infrastructure on AWS or other clouds.
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.
Nicola Ferraro and Luca Burgazzoli presented on Apache Camel K, a lightweight integration platform for running integrations on Kubernetes. Camel K allows developers to write integration logic in a simple DSL and have it run as serverless functions on Kubernetes. It integrates well with Knative for auto-scaling and can connect to over 300 components. The presentation demonstrated Camel K's use in a event mesh and discussed current developments including support for Quarkus, Kamelets for reusable integration snippets, and testing with YAKS. Camel K aims to simplify building integrations in a cloud native environment.
Helm - Application deployment management for KubernetesAlexei Ledenev
Use Helm to package and deploy a composed application to any Kubernetes cluster. Manage your releases easily over time and across multiple K8s clusters.
This document provides an overview of microservices architecture, including concepts, characteristics, infrastructure patterns, and software design patterns relevant to microservices. It discusses when microservices should be used versus monolithic architectures, considerations for sizing microservices, and examples of pioneers in microservices implementation like Netflix and Spotify. The document also covers domain-driven design concepts like bounded context that are useful for decomposing monolithic applications into microservices.
Kubernetes Helm makes application deployment easy, standardized and reusable. Use of Kubernetes Helm leads to better developer productivity, reduced Kubernetes deployment complexity and enhanced enterprise production readiness.
Enterprises using Kubernetes Helm can speed up the adoption of cloud native applications. These applications can be sourced from open-source community provided repositories, or from an organization’s internal repository of customized application blueprints.
Developers can use Kubernetes Helm as a vehicle for packaging their applications and sharing them with the Kubernetes community. Kubernetes Helm also allows software vendors to offer their containerized applications at “the push of a button.” Through a single command or a few mouse clicks, users can install Kubernetes apps for dev-test or production environments.
The document provides an overview of Terraform, including that it is a declarative provisioning tool that uses HCL or JSON to safely evolve infrastructure in a predictable way. It discusses Terraform's use of graph theory to identify dependencies, its plugin-based architecture to compose multiple cloud services, and its core concepts like providers, resources, data sources, and the workflow of plan, apply, and destroy.
This document provides an overview of cloud native concepts including:
- Cloud native is defined as applications optimized for modern distributed systems capable of scaling to thousands of nodes.
- The pillars of cloud native include devops, continuous delivery, microservices, and containers.
- Common use cases for cloud native include development, operations, legacy application refactoring, migration to cloud, and building new microservice applications.
- While cloud native adoption is growing, challenges include complexity, cultural changes, lack of training, security concerns, and monitoring difficulties.
State of integration with Apache Camel (ApacheCon 2019)Claus Ibsen
Apache Camel is the leading open source integration framework, which has been around for over a decade. In this talk we will look back in history, to understand how the integration landscape has evolved from EAI, SOA, and ESB architectures up to microservices, and now with modern serverless and cloud native platforms. Apache Camel has been along for the ride. And we will look to the future and see how the latest release v3 of Apache Camel, is aimed for running modern cloud native workloads with Camel K. In this talk you will: Learn from history software integration, and why you should rely on existing, proven fully featured integration frameworks instead of rolling out your own DIY solutions. See how software integration is (still) important in today’s modern architectures and what role does Camel have in the new cloud native world. What is new and noteworthy in Apache Camel version 3
Camel K allows building and deploying Apache Camel integration applications on Kubernetes in about 1 second. It provides a lightweight runtime for Camel on Kubernetes that enables low-code/no-code integration using Camel's Java DSL. Camel K applications can take advantage of serverless capabilities provided by Knative like autoscaling and scaling to zero. Quarkus is a Kubernetes-native Java stack that provides a minimal footprint and container-first experience for building microservices. It works well with Camel/Camel K by enabling native compilation of Camel routes for very fast startup times and low memory usage.
SouJava May 2020: Apache Camel 3 - the next generation of enterprise integrationClaus Ibsen
In this session, we'll discuss:
- What’s Apache Camel: An overview of Camel and what you use it for and why you should care.
- Camel 3: Demos of how Camel 3, Camel K and Camel Quarkus all work together, and will provide insights into Camel’s role in the next major release of Red Hat Integration products.
- Camel K: This serverless integration platform provides low-code/no-code capabilities, where integrations can be snapped together quickly using the powers from integration patterns and Camel’s extensive set of connectors.
- Camel Quarkus: Using Knative (the fast runtime of Quarkus) and Camel K brings awesome serverless features, such as auto-scaling, scaling to zero, and event-based communication, with great integration capabilities from Apache Camel.
You will also hear about the latest Camel sub-project Camel Kafka Connectors which makes it possible to use all the Camel components as Kafka Connect connectors.
Finally we bring details of the roadmap for what is coming up in the Camel projects.
And after the presentation we have about 30 minutes of QA answering all the questions from the audience.
Apache Camel is a leading open source integration framework that has been around for more than a decade. With the release of Apache Camel 3, the Camel family has been extended to include a full range of projects that are tailored to popular platforms including Spring Boot, Quarkus, Kafka, Kubernetes, and others - creating an ecosystem. Join this webinar to learn what’s new in Camel 3 and about Camel projects: - Latest features in Camel 3 - Quick demos of Camel 3, Camel Quarkus, Camel K, and Camel Kafka Connector - Present insights into what's coming next
Speakers: Andrea Cosentino, Claus Ibsen
DevNation Live 2020 - What's new with Apache Camel 3Claus Ibsen
Join this webinar to learn what’s new in Camel 3 and about Camel projects:
- Latest features in Camel 3
- Quick demos of Camel 3, Camel #Quarkus, #CamelK, and Camel Kafka Connector
- Present insights into what's coming next
This document provides an overview of Apache Camel K, which allows building and deploying Apache Camel integration applications on Kubernetes in under one second. Camel K uses operators and custom resources to deploy Camel routes defined in Groovy files to Kubernetes. It provides a lightweight runtime for developing cloud-native integration microservices on Kubernetes without needing to build Docker images or configure Kubernetes resources manually. The document outlines some limitations of Camel K as an early project but notes its potential for rapid prototyping of simple integration logic in cloud environments.
Camel Kafka Connectors: Tune Kafka to “Speak” with (Almost) Everything (Andre...HostedbyConfluent
Apache Kafka is getting used as an event backbone in new organizations every day. We would love to send every byte of data through the event bus. However, most of the time, connecting to simple third party applications and services becomes a headache that involves several lines of code and additional applications. As a result, connecting Kafka to services like Google Sheets, communication tools such as Slack or Telegram, or even the omnipresent Salesforce, is a challenge nobody wants to face. Wouldn’t you like to have hundreds of connectors readily available out-of-the-box to solve this problem?
Due to these challenges, communities like Apache Camel are working on how to speed up development of key areas of the modern application, like integration. The Camel Kafka Connect project, from the Apache foundation, has enabled their vastly set of connectors to interact with Kafka Connect natively. So, developers can start sending and receiving data from Kafka to and from their preferred services and applications in no time without a single line of code.
In summary, during this session we will:
- Introduce you to the Camel Kafka Connector sub-project from Apache Camel
- Go over the list of connectors available as part of the project
- Showcase a couple of examples of integrations using the connectors
- Share some guidelines on how to get started with the Camel Kafka Connectors
Red Hat Nordics 2020 - Apache Camel 3 the next generation of enterprise integ...Claus Ibsen
In this session, we'll focus on:
Camel 3: Demos of how Camel 3, Camel K and Camel Quarkus all work together, and will provide insights into Camel’s role in the next major release of Red Hat Integration products.
Camel K: This serverless integration platform provides low-code/no-code capabilities, where integrations can be snapped together quickly using the powers from integration patterns and Camel’s extensive set of connectors.
Camel Quarkus: Using Knative (the fast runtime of Quarkus) and Camel K brings awesome serverless features, such as auto-scaling, scaling to zero, and event-based communication, with great integration capabilities from Apache Camel.
You will also hear about the latest Camel sub-project Camel Kafka Connectors which makes it possible to use all the Camel components as Kafka Connect connectors.
Finally we bring details of the roadmap for what is coming up in the Camel projects.
Flying Server-less on the Cloud with AWS LambdaSerkan Özal
This document discusses using AWS Lambda for serverless computing on the cloud. It covers topics such as what AWS Lambda is, its motivations, under the hood details of how it works, integrations with other AWS services, limitations, logging, configuration management, security, error handling, monitoring, alerting, testing, deployment practices, performance considerations including cold starts, and examples of using AWS Lambda at OpsGenie for incident management and data replication.
This document provides an overview of Apache Camel, an open source integration framework for connecting applications and integrating disparate systems. It discusses what Camel is, its key features like support for Enterprise Integration Patterns and Domain Specific Languages, components, architecture, platforms, testing, tooling, security, and hands-on examples.
Cloud State of the Union for Java DevelopersBurr Sutter
This presentation provides a broad overview of what is going on in the Cloud computing world - for Java developers - presented on Dec 21st 2010 at the Atlanta Java Users Group - ajug.org - no audio was recorded.
In this session Stephan Hartmann presents Metamesh's OpenCms Cloud eXtensions (OCCX) implementation, which is the foundation to provide a cloud-ready, distributable and cluster-ready version of OpenCms that implements an integration with Open Data Grid Platforms. Arash Kaffamanesh will present OCCX in action running on Eucalyptus Private Cloud and Amazon EC2 and shows you the first cloudified version of OpenCms with Auto-Scaling and Multi-Workplace support for your OpenCms SaaS initiatives.
(BDT303) Running Spark and Presto on the Netflix Big Data PlatformAmazon Web Services
In this session, we discuss how Spark and Presto complement the Netflix big data platform stack that started with Hadoop, and the use cases that Spark and Presto address. Also, we discuss how we run Spark and Presto on top of the Amazon EMR infrastructure; specifically, how we use Amazon S3 as our data warehouse and how we leverage Amazon EMR as a generic framework for data-processing cluster management.
Running Presto and Spark on the Netflix Big Data PlatformEva Tse
This document summarizes Netflix's big data platform, which uses Presto and Spark on Amazon EMR and S3. Key points:
- Netflix processes over 50 billion hours of streaming per quarter from 65+ million members across over 1000 devices.
- Their data warehouse contains over 25PB stored on S3. They read 10% daily and write 10% of reads.
- They use Presto for interactive queries and Spark for both batch and iterative jobs.
- They have customized Presto and Spark for better performance on S3 and Parquet, and contributed code back to open source projects.
- Their architecture leverages dynamic EMR clusters with Presto and Spark deployed via bootstrap actions for scalability.
AWS reinvent 2019 recap - Riyadh - Containers and Serverless - Paul MaddoxAWS Riyadh User Group
This document provides an overview and agenda for an AWS storage, compute, containers, serverless, and management tools presentation. It includes summaries of several upcoming AWS services and features related to EBS, S3, EC2, EKS, Fargate, Lambda, and AWS Cost Optimizer. The speaker is introduced as Paul Maddox, Principal Architect at AWS, with a background in development, SRE, and systems architecture.
(SEC403) Diving into AWS CloudTrail Events w/ Apache Spark on EMRAmazon Web Services
Do you want to analyze AWS CloudTrail events within minutes of them arriving in your Amazon S3 bucket? Would you like to learn how to run expressive queries over your CloudTrail logs? We will demonstrate Apache Spark and Apache Spark Streaming as two tools to analyze recent and historical security logs for your accounts. To do so, we will use Amazon Elastic MapReduce (EMR), your logs stored in S3, and Amazon SNS to generate alerts. With these tools at your fingertips, you will be the first to know about security events that require your attention, and you will be able to quickly identify and evaluate the relevant security log entries.
Apache Camel has fundamentally changed the way enterprise Java™ developers think about system-to-system integration by making enterprise integration patterns (EIP) a simple declaration in a lightweight application wrapped and delivered as a single JAR.
Python Streaming Pipelines on Flink - Beam Meetup at Lyft 2019Thomas Weise
Apache Beam is a unified programming model for batch and streaming data processing that provides portability across distributed processing backends. It aims to support multiple languages like Java, Python and Go. The Beam Python SDK allows writing pipelines in Python that can run on distributed backends like Apache Flink. Lyft developed a Python SDK runner for Flink that translates Python pipelines to native Flink APIs using the Beam Fn API for communication between the SDK and runner. Future work includes improving performance of Python pipelines on JVM runners and supporting multiple languages in a single pipeline.
Porting a Streaming Pipeline from Scala to RustEvan Chan
How we at Conviva ported a streaming data pipeline in months from Scala to Rust. What are the important human and technical factors in our port, and what did we learn?
Semelhante a Apache Camel v3, Camel K and Camel Quarkus (20)
Low Code Integration with Apache Camel.pdfClaus Ibsen
Design your integration flows using Camel and JBang for a better developer experience, and make it easily production grade using Quarkus.
Claus Ibsen, Apache Camel lead & Senior Principal Software Engineer, Red Hat
Camel CLI (Camel JBang) provides an easy way to try Apache Camel without extensive configuration. It allows installing Camel dependencies with jbang, developing and running Camel integrations locally, and exporting projects to runtimes like Quarkus. Current features include dependency management, running Camel DSLs, hot reloading, and exporting to Spring Boot. Future plans include managing multiple integrations, improved health checks, and running on additional runtimes. Camel JBang aims to lower the barrier to experimenting with Camel.
JEEConf 2018 - Camel microservices with Spring Boot and KubernetesClaus Ibsen
Apache Camel has fundamentally changed the way enterprise Java developers think about system-to-system integration by making enterprise integration patterns (EIP) a simple declaration in a lightweight application wrapped and delivered as a single JAR.
In this session, we’ll show you how to bring the best practices from the EIP world together with containers, running on top of Kubernetes, and deployed as Spring Boot microservices, which are both cloud-native and cloud-portable.
Building and designing cloud-native microservices impacts how we develop. We’ll discuss practices how to build distributed and fault-tolerant microservices with technologies such as Kubernetes Services, Netflix Hystrix, Camel EIP patterns, and Istio. You will see live demos of us killing containers to test fault tolerance, and more.
The document provides an overview and summary of a presentation titled "Camel riders in the cloud" given at Red Hat DevNation Live in March 2018. The presenter is a senior principal software engineer at Red Hat and long-time committer to the Apache Camel project. The presentation discusses how Apache Camel can be used for distributed integration in microservices and containerized architectures running in the cloud. It outlines best practices for running Camel in containers, including keeping Camel components small, stateless, and using configuration management. Fault tolerance, health checks, Enterprise Integration Patterns, and distributed tracing are also covered.
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.
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.
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.
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.
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.
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.
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.
Apache Camel Introduction & What's in the boxClaus Ibsen
Slides from JavaBin talk in Grimstad Norway, presented by Claus Ibsen in February 2016.
This slide deck is full up to date with latest Apache Camel 2.16.2 release and includes additional slides to present many of the features that Apache Camel provides out of the box.
Microservices with apache_camel_barcelonaClaus 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 micro services 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.
The second part of this talk is about running Camel in the cloud.We start by showing you how you can use the Maven Docker Plugin to create a docker image of your Camel application and run it using docker on a single host. Then kubernetes enters the stage and we take a look at how you can deploy your docker images on a kubernetes cloud platform, and how the fabric8 tooling can make this much easier for the Java developers.
At the end of this talk you will have learned about and seen in practice how to take a Java Camel project from scratch, turn that into a docker image, and how you can deploy those docker images in a scalable cloud platform based on Google's kubernetes.
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 micro services 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.
The second part of this talk is about running Camel in the cloud. We start by showing you how you can use the Maven Docker Plugin to create a docker image of your Camel application and run it using docker on a single host. Then kubernetes enters the stage and we take a look at how you can deploy your docker images on a kubernetes cloud platform, and how thenfabric8 tooling can make this much easier for the Java developers.
At the end of this talk you will have learned about and seen in practice how to take a Java Camel project from scratch, turn that into a docker image, and how you can deploy those docker images in a scalable cloud platform based on Google's kubernetes.
Integration using Apache Camel and GroovyClaus Ibsen
Apache Camel is versatile integration library that supports a huge number of components, enterprise integration patterns, and programming languages.
In this this talk I first introduce you to Apache Camel and its concepts. Then we move on to see how you can use the Groovy programming language with Camel as a first class Groovy DSL to build integration flows.
You will also learn how to build a new Camel and Groovy app from scratch from a live demo.
And we also touch how you can use Camel from grails using the grails-camel plugin.
I will also show the web console tools that give you insight into your running Apache Camel applications, including visual route diagrams with tracing, debugging, and profiling capabilities.
This session will be taught with a 50/50 mix of slides and live demos, and it will conclude with Q&A time.
Getting Started with Apache Camel at DevNation 2014Claus Ibsen
Get off to a good start with Apache Camel. This session will give you an introduction to Apache Camel and teach you:
- How Camel is related to enterprise integration patterns (EIPs).
- How to use EIPs in Camel routes written in Java code or XML files.
- How to get started developing with Camel, including how to set up new projects from scratch using Maven and Eclipse.
- With a live demo, how to build Camel applications in Java, Spring, and OSGi Blueprint.
- How ready-to-use features make integration much easier.
- About the web console tools that give you insight into your running Apache Camel applications, including visual route diagrams with tracing, debugging, and profiling capabilities.
- Useful resources to learn more about Camel.
This session will be taught with a 50/50 mix of slides and live demos, and it will conclude with Q&A time.
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!!
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
Top 9 Trends in Cybersecurity for 2024.pptxdevvsandy
Security and risk management (SRM) leaders face disruptions on technological, organizational, and human fronts. Preparation and pragmatic execution are key for dealing with these disruptions and providing the right cybersecurity program.
Mobile app Development Services | Drona InfotechDrona Infotech
Drona Infotech is one of the Best Mobile App Development Company In Noida Maintenance and ongoing support. mobile app development Services can help you maintain and support your app after it has been launched. This includes fixing bugs, adding new features, and keeping your app up-to-date with the latest
Visit Us For :
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
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
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
Microservice Teams - How the cloud changes the way we work
Apache Camel v3, Camel K and Camel Quarkus
1. Apache Camel v3
Camel K
Camel Quarkus
Claus Ibsen
Senior Principal Software Engineer
Red Hat
November 2019
2. About me
Claus Ibsen
● Senior Principal Software Engineer at Red Hat
● ASF Member & Java Champion
● Apache Camel tech lead
● Author of Camel in Action books
● Based in Denmark
● Blog: https://medium.com/@davsclaus
3. Agenda
● Integration Evolution
● Apache Camel
● Camel 3
● Camel K
● Serverless
● Camel K & Knative
● Camel Quarkus
● Roadmap
● More Material
18. What is Apache Camel
● The swiss knife of integration
● 10+ years of development and one
of the most active Apache projects
19. What is Apache Camel
● Packed with functionality
The giant Swiss knife 😅
20. What is Apache Camel
● Java based integration framework
● Runtime support: Spring Boot, Apache Karaf / OSGi, JEE / WAR,
Microprofile, Quarkus, Standalone, and more ...
● Based on Enterprise Integration Patterns
● Comes with 300+ components (connectors)
● DSL (Java or XML) to describe integration flow (routes)
● Can integrate everything ... almost everything
● 10+ years of development - still one of the most active Apache projects
● The cornerstone of Red Hat Fuse
58. Camel 3 - Reactive
● Reactive Core
○ All EIPs now fully reactive
○ Blocking vs Non-Blocking code-paths merged into one (Non-Blocking)
● Postponed for Camel 3.x
○ Backpressure
○ Client API
○ Java 9+ Flowable API (requires to drop Java 8)
59. Camel 3 - Camel Main
● Standalone Camel
○ Bootstrap for Camel K & Camel Quarkus
○ Unified configuration (also for Camel Spring Boot)
● Configurable
○ application.properties (ala Spring Boot)
● Tooling Support
○ Eclipse
○ Eclipse Che
○ VSCode
○ IDEA
61. Camel 3 - Other
● JUnit 5 support
○ camel-test-junit5
● Step EIP
○ Group together N+ EIPs (logical name)
○ Grouped performance statistics
● Lazy start producer
○ Avoid Camel to fail on startup if producer fails to start
(typically connecting to remote system)
● Writeable Registry
○ Easier to add your own beans
● Route Model more extensible
○ YAML route builder (Camel K)
62. 19/12/2018
Master switched
to camel 3
02/2019
M1
❏ New Camel API
❏ Move components
out of camel core
❏ Extract basic
classes in a support
JAR
❏ Reactive Routing
Engine
❏ Faster releases
❏ Quarkus Support
for a subset of
components
❏ Writeable registry
❏ Step EIP
❏ Faster build
❏ Reactive Routing
Engine improved
❏ Java 11 support
improved
❏ EIP at scale
❏ More Quarkus
support
Final
Release
04/2019
M2
06/2019
M3
07/2019
M4
❏ Auto-generate
Endpoint DSL
❏ Camel-core-engine
❏ Camel-main
improved
❏ Website and docs
almost done
09/2019
RC1
❏ Renaming
components
❏ New website live
❏ Stabilizing
❏ Reduce footprint
Camel 3 - Timeline
10/2019
RC2 RC3
12/2019
GA
5700+ commits (Camel 3.x)
64. A lightweight integration platform, based on Apache Camel,
born on Kubernetes, with serverless superpowers.
What is Apache Camel K ?
65. A lightweight integration platform, based on Apache Camel,
born on Kubernetes, with serverless superpowers.
What is Apache Camel K ?
Runs on “vanilla” Kubernetes (1) ...
K
1.
66. A lightweight integration platform, based on Apache Camel,
born on Kubernetes, with serverless superpowers.
What is Apache Camel K ?
Runs on “vanilla” Kubernetes (1), Openshift (2) ...
K
1.
K
2.
67. A lightweight integration platform, based on Apache Camel,
born on Kubernetes, with serverless superpowers.
What is Apache Camel K ?
Runs on “vanilla” Kubernetes (1), Openshift (2) and gives its best on a Knative-powered cluster (3)!
K
1.
K
2.
K
3.
72. Architecture of Camel K
Dev Environment Remote Cloud
kamel CLI
Camel K
Operator
“Integration”
Custom
Resource
Running Pod
Live updates!
Fast redeploy!
Less than 1 second!
Tailored for cloud-native development experience
73. Fast Deployment of Camel K
Time to run a integration using different strategies (in seconds)
Lower is better
😃
F-m-p is the “fabric8-maven-plugin”
(http://maven.fabric8.io/) deploying a
average spring-boot based
integration on Minishift vs. a remote
OpenShift cluster (accounting time to
upload the fat Jar). Source S2I build
has been measured in Red Hat Fuse
Online.
79. What is serverless?
“Serverless computing refers to the concept of building and running applications
that don’t require server management. It describes a finer-grained deployment
model where applications, bundled as one or more functions, are uploaded to a
platform and executed, scaled, billed in response to the exact demand needed”
https://github.com/cncf/wg-serverless
Serverless personas:
● Developer: writes code for, and benefits from the serverless platform.
● Provider: manages the serverless platform.
80. What is serverless?
“Serverless computing refers to the concept of building and running applications that
don’t require server management. It describes a finer-grained deployment model
where applications, bundled as one or more functions, are uploaded to a platform and
executed, scaled, billed in response to the exact demand needed”
https://github.com/cncf/wg-serverless
Serverless personas:
● Developer: writes code for, and benefits from the serverless platform.
● Provider: manages the serverless platform.
81. Serverless (Compute)
Here’s my personal definition of “serverless”.
Before it becomes a billing model, we need to define it “technically”.
Serverless is a programming model based on:
82. Serverless (Compute)
Here’s my personal definition of “serverless”.
Before it becomes a billing model, we need to define it “technically”.
Serverless is a programming model based on:
...
1) Auto-scaling services/functions
(including scaling to zero)
83. 2) Event-driven execution
Serverless (Compute)
Here’s my personal definition of “serverless”.
Before it becomes a billing model, we need to define it “technically”.
Serverless is a programming model based on:
...
1) Auto-scaling services/functions
(including scaling to zero)
84. Serverless requirements
For the platform
● Scaling to zero
● Rapid scaling up and down
● Eventing mechanism
● Routing and networking
For the application runtime
● Fast startup
● Fast first response
● Low on memory and CPU
● Small size on disk
85. Serverless requirements
For the platform
● Scaling to zero
● Rapid scaling up and down
● Eventing mechanism
● Routing and networking
For the application runtime
● Fast startup
● Fast first response
● Low on memory and CPU
● Small size on disk
K
88. Build
A pluggable model for
building artifacts, like jar
files, zips or containers
from source code.
Knative Overview - Components
Serving
An event-driven model
that serves the container
with your application and
can "scale to zero".
Eventing
Common infrastructure for
consuming and producing
events that will stimulate
applications.
Kubernetes-based platform to build, deploy, and manage modern serverless workloads
90. Camel K and Knative
<<custom-resource>>
Build
Knative components relevance to Camel
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Eventing
Standardize building
container images
Auto-scaling and scale-to-zero Messaging for event-based
applications
<<custom-resource>>
Channel
91. Camel K and Knative
<<custom-resource>>
Build
Knative components relevance to Camel
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Eventing
Standardize building
container images
Auto-scaling and scale-to-zero Messaging for event-based
applications
<<custom-resource>>
Channel
XNo longer included in
Knative
Use external projects
such as Tekton
92. Camel K and Knative
<<custom-resource>>
Build
Knative components relevance to Camel
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Eventing
Standardize building
container images
Auto-scaling and scale-to-zero Messaging for event-based
applications
<<custom-resource>>
Channel
X
93. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
94. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
95. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Request
96. Camel K and Knative Serving
Kubernetes Namespace
A container is created only when needed!
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Request Pod
97. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Request Pod
98. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Request Pod
99. Camel K and Knative Serving
Kubernetes Namespace
Scale to zero when no load
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
100. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Multiple containers under high load!
Request Pod
Request
Request
Pod
Pod
101. Camel K and Knative Serving
Kubernetes Namespace
rest().post(“/path”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Scale to zero when no load
102. Camel K and Knative
<<custom-resource>>
Build
Knative components relevance to Camel
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Build
<<custom-resource>>
Service
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Serving
<<custom-resource>>
...<<custom-resource>>
...<<custom-resource>>
...
Knative Eventing
Standardize building
container images
Auto-scaling and scale-to-zero Messaging for event-based
applications
<<custom-resource>>
Channel
X
103.
104. Kubernetes Namespace
Camel K and Knative Eventing
300+ components!
System 1
System 2
Channel a
Persisted by
Kafka, in-memory
(pluggable)
105. Kubernetes Namespace
Camel K and Knative Eventing
from(“knative:channel/a”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
Channel a
106. Kubernetes Namespace
Camel K and Knative Eventing
from(“knative:channel/a”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
Cloud Event
https://cloudevents.io/
Channel a
107. Kubernetes Namespace
Camel K and Knative Eventing
from(“knative:channel/a”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
PodCloud Event
https://cloudevents.io/
Channel a
108. Kubernetes Namespace
Camel K and Knative Eventing
from(“knative:channel/a”)
.to(“xx:system1”)
.to(“xx:system2”)
300+ components!
System 1
System 2
Knative
Service
Knative
Subscription
PodCloud Event
https://cloudevents.io/
Channel a
109. Camel K: same model for different purposes
Camel K and Knative Eventing
Channel
Channel
Channel
Ext
System
110. Camel K: same model for different purposes
Camel K and Knative Eventing
Channel
Channel
Channel
Ext
System
Event
Source
(Sink)
300+ components!
111. Camel K: same model for different purposes
Camel K and Knative Eventing
Channel
Channel
Channel
Ext
System
Event
Source
(Sink)
Enterprise
Integration
Patterns
(Routing)
300+ components!
65+ patterns
112. Camel K: same model for different purposes
Camel K and Knative Eventing
Channel
Channel
Channel
Ext
System
Event
Source
(Sink)
Enterprise
Integration
Patterns
(Routing)
Function
(Integration)
300+ components!
300+ components!
65+ patterns
113. Knative Eventing includes Camel
Standard Knative
Sources
That can be used
without any knowledge
of Camel K!
... but Camel K is under the
hood :)
114. Apache Camel K on CNCF
https://camel.apache.org/blog/CamelK-CNCF-Landscape/
119. Camel K and Knative Demo
legacy.
groovy
channel/in
120. Camel K and Knative Demo
legacy.
groovy
channel/in
process.
groovy
121. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
122. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
123. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
124. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
125. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
126.
127. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
128.
129. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
130.
131. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
132. Quarkus is now supported out of the box with
Camel K since this demo was created
(no longer needed to build your own kit)
https://camel.apache.org/camel-k/latest/traits/quarkus.html
133. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
134.
135. Camel K and Knative Demo
legacy.
groovy
channel/in
channel/out
channel/null
process.
groovy
quarkus.
yaml
telegram.
groovy
139. Characteristic Monolithic/SOA Microservies/CNA Functions/Serverless
Packaging Ear/War/Jar Fat-jar Native executable
Startup procedure XML scanning Annotation scanning Instant (ahead-of-time compilation)
Memory/binary size 1000s MBs 100s MBs 10s of MBs
Startup/first response Minutes Seconds Milliseconds
Process lifecycle Long running Managed by platform Ephemeral (executed per request)
State (app/user) Stateful Stateless (no user state) Ephemeral (no application state)
Data ownership Shared data model Owns data No data ownership
Operations Multiple unrelated operations Multiple domain operations Single event driven operation
Scope Multiple business domains Single business domain Single task
Motivation Non-scalable, high complexity
domains
Portable, autonomous,
scalable workloads
Rapid productivity, at the expense
of control and portability
Application trends (Java)
142. Java Density Problem
CONTAINER ORCHESTRATION
Node Node Node
Traditional Cloud-Native
Java Stack
Traditional Cloud-Native
Java Stack
Traditional Cloud-Native
Java Stack
Traditional Cloud-Native
Java Stack
NodeJS
NodeJS
NodeJS
NodeJS
NodeJS
NodeJS
NodeJS
Go Go Go
Go Go Go
Go Go Go
Go Go Go
Go Go Go
Go Go Go
Go Go Go
https://developers.redhat.com/blog/2017/03/14/java-inside-docker/
146. What is Quarkus ?
Supersonic Subatomic Java
A Kubernetes Native Java stack tailored for GraalVM &
OpenJDK HotSpot, crafted from the best of breed Java libraries
and standards
152. Camel K - Roadmap
● Support for Camel 3 (Now RC3, GA in Nov/Dec 2019)
○ Lightweight modules to reduce footprint
○ Webhook meta-component (more components that
can scale down to 0)
○ Camel K 1.0.0-M3 supports Camel 3.0.0-RC1
● Quarkus as integration runtime
○ Reduced footprint and cold start-up time
○ Native image build in parallel swapped with JVM
image during auto-scaling once ready
● Knative 1.0 → Camel K 1.0.0
● Support the Broker / Trigger model
● Support Tekton builds
● Push-based endpoints
● Fully integrated with Syndesis / Fuse Online
● Better IDE support
● Better integration with CI tools
● BDD testing
● Operator Capability Level 3+
153. Camel Quarkus - Roadmap
● Camel Extensions on http://code.quarkus.io
● Port more Camel components as Extensions
(22 done out of 300)
● More build time optimisations
● Reduce startup overhead
● Quarkus 1.0 → Camel Quarkus 1.0.0
● Better IDE support
154. Camel Kafka Connector
● A kafka connector source and sink implementation that embeds camel.
● It is configurable to use most of the camel-components.
● Making it able to talk with 300+ different kind of external systems.
300+ components!
155. Camel Debezium
● Stream changes from databases to Camel
● camel-debezium component in Camel 3
○ MySQL connector
○ Other databases on the way ...
Debezium
https://www.youtube.com/watch?time_continue=12&v=xLXx8bUyTtk
161. Serverless Integration
Microservices Microservices Microservices External SaaS
External SaaS
External SaaS
External SaaS
Integration
function
Integration
function
Integration
function
Integration
function
Integration
function
KNative
Service
Service
Service
Service
Microservices Microservices
function
166. More Material
● Apache Camel K
https://github.com/apache/camel-k
● Apache Camel Quarkus
https://github.com/apache/camel-quarkus
● Quick Camel K demo
https://www.youtube.com/watch?v=I-g2xt-Qcb8
● Camel K Introduction Blog
https://www.nicolaferraro.me/2018/10/15/introducing-camel-k
● Kubernetes enterprise integration patterns with Camel K webinar
https://www.youtube.com/watch?v=51x9BewGCYA
● Camel K and Knative video
https://www.youtube.com/watch?v=lOqubmVSGdw