Getting started with Apache Camel - jDays 2013

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.

This document discusses Enterprise Integration Patterns (EIPs) using Apache Camel, a Java framework for integration and mediation. It provides an overview of common EIPs like content-based routing, normalization, and the transactional client pattern. It also demonstrates how to implement EIPs like these using the Java and Spring DSLs in Camel. Key features of Camel like components, exchanges, processors and error handling are explained. Tools for working with Camel like Fuse IDE and Hawt.io are also introduced.

This document discusses Apache Camel, an open-source integration framework. It begins with an overview of Camel and enterprise integration patterns. A live demo then shows how to route messages using the Java DSL. The document outlines the key components of Camel, including over 120 connectors, data formats, expression languages and domain-specific languages. It also covers testing, deployment options, and management of Camel applications.

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.

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/

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.

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

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.

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.

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!

My Apache Camel presentation from the FUSE community day event, London June 2010. A video/audio/transcript of the presentation is in the works and will later be published at the fusesource (http://fusesource.com) website.

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.

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.

This presentation describes Event Driven Architecture(EDA) support in Camel, and scalability features like SEDA and Akka support in Camel.It starts with an overview of Camel and introduces its simple syntax

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.

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.

This document discusses Docker and how it can be used to deploy Apache Camel applications and microservices. It provides an overview of key Docker concepts like images and containers. It then discusses how to structure a Camel application and split it into Docker containers for the different components. Examples are given of Dockerizing Camel routes that connect to ActiveMQ and MongoDB. The document also recommends using Spring Boot to simplify building and running Camel applications in Docker containers.

ActiveMQ is an open source message broker that implements the Java Message Service (JMS) API. It allows applications written in different languages to communicate asynchronously. Apache Camel is an open source integration framework that can be used to build messaging routes between different transports and APIs using a simple domain-specific language. It provides mediation capabilities and supports common integration patterns. Both ActiveMQ and Camel aim to simplify integration between disparate systems through message-based communication.

Building microservices requires more than just infrastructure, but infrastructure does have a role. In this talk we look at microservices from an enterprise perspective and talk about DDD, Docker, Kubernetes and how established open-source projects in the integration space fits a microservices architecture

Developing integration microservices using CI/CD with apache camel, open shift, fabric8.io, jenkins, et al.

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.

The document discusses microservices and APIs. It covers how microservices optimize for speed by shedding dependencies and having dependencies on demand through services and APIs. It discusses consumer contracts for APIs and service versioning. It also discusses using an API gateway pattern for scalability, security, monitoring and more. It promotes API management for benefits like access control, analytics, and monetization of microservices.

10 yrs ago, SOA promised a lot of the same things Microservices promise use today. So where did we go wrong? What makes microservices different? In this talk, we discussed from an architectural view how we went sideways with SOA, why we must embrace things like Domain Driven Design and scaled-out architectures, and how microservices can be built with enterprises in mind. We also cover a step-by-step, in-depth tutorial that covers these concepts.

Slides from QConSF Nov 19th, 2011 focusing this time on describing the globally distributed and scaled industrial strength Java Platform as a Service that Netflix has built and run on top of AWS and Cassandra. Parts of that platform are being released as open source - Curator, Priam and Astyanax.

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.

Christian Posta is a principal middleware specialist and architect who has worked with large microservices architectures. He discusses why companies are moving to microservices and cloud platforms like Kubernetes and OpenShift. He covers characteristics of microservices like small autonomous teams and decentralized decision making. Posta also discusses breaking applications into independent services, shedding dependencies between teams, and using contracts and APIs for communication between services.

Microservices architecture is a very powerful way to build scalable systems optimized for speed of change. To do this, we need to build independent, autonomous services which by definition tend to minimize dependencies on other systems. One of the tenants of microservices, and a way to minimize dependencies, is “a service should own its own database”. Unfortunately this is a lot easier said than done. Why? Because: your data. We’ve been dealing with data in information systems for 5 decades so isn’t this a solved problem? Yes and no. A lot of the lessons learned are still very relevant. Traditionally, we application developers have accepted the practice of using relational databases and relying on all of their safety guarantees without question. But as we build services architectures that span more than one database (by design, as with microservices), things get harder. If data about a customer changes in one database, how do we reconcile that with other databases (especially where the data storage may be heterogenous?). For developers focused on the traditional enterprise, not only do we have to try to build fast-changing systems that are surrounded by legacy systems, the domains (finance, insurance, retail, etc) are incredibly complicated. Just copying with Netflix does for microservices may or may not be useful. So how do we develop and reason about the boundaries in our system to reduce complexity in the domain? In this talk, we’ll explore these problems and see how Domain Driven Design helps grapple with the domain complexity. We’ll see how DDD concepts like Entities and Aggregates help reason about boundaries based on use cases and how transactions are affected. Once we can identify our transactional boundaries we can more carefully adjust our needs from the CAP theorem to scale out and achieve truly autonomous systems with strictly ordered eventual consistency. We’ll see how technologies like Apache Kafka, Apache Camel and Debezium.io can help build the backbone for these types of systems. We’ll even explore the details of a working example that brings all of this together.

The document discusses Christian Posta's journey with microservices architectures. It begins by explaining why organizations are moving to microservices and defines microservices. It then covers related topics like cloud platforms, container technologies like Kubernetes and OpenShift, benefits and drawbacks of microservices, and tools for developing microservices like Docker, Kubernetes, OpenShift, and Camel.

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.

Edison Wong presented on using Ansible for DevOps automation. He discussed using Ansible to deploy applications to Kubernetes and managing infrastructure as code. He demonstrated testing roles locally with Molecule and testing complex clusters with Vagrant. Wong emphasized starting with test cases and using different test drivers like Docker, LXD, and Vagrant based on the complexity of what is being tested.

The BBC moved their OWLIM graph database to Amazon Web Services (AWS) to take ownership of OWLIM maintenance and support AWS adoption. They deployed OWLIM using AWS OpsWorks to define the infrastructure and Chef recipes to install and configure each layer. While OpsWorks and Chef provide benefits like simplicity and reuse, autoscaling is not supported and Chef recipes could be improved. Future plans include autoscaling, backup improvements, and refactoring Chef recipes.

Eclipse Buildship allows Gradle projects to be imported and worked with in Eclipse. It provides features like running Gradle tasks in Eclipse, visualizing task execution, and creating new Gradle projects from templates. Future plans include improving views for tasks, plugins, and components as well as adding debug configuration support. Buildship is open source and contributions are welcome.

Edison Wong gave a presentation on using Ansible to manage virtual machines, Docker containers, and Kubernetes clusters. He discussed using Ansible roles tested with Molecule and deployed with Vagrant and Libvirt. He demonstrated an Ansible role for SSH that is tested with Molecule and Docker image building with Molecule. Finally, he showed an Ansible collection for deploying Kubernetes and Ceph that is tested at the role level with Molecule, Vagrant and Libvirt.

With the rise of Docker, we have seen an unprecedented interest in container technologies where small companies and big enterprises bet their future on these technologies. This trend bases on an immense adoption of containers from software developers. And it has been agreed upon that they are considered highly beneficial for modern engineering practices like Agile and DevOps. But there is a new kid in town that proclaims a more radical approach: Serverless or FaaS: Function-As-A-Service. This paradigm suggests that a developer should only write functions and react to events. The functions are written in high-level programming languages like Javascript, Java or Python, and the underlying compute infrastructure like containers or VMs is transparent to the user. That raises the question: Is the container revolution already dead before it really started? And who now needs container technologies in a serverless world? In this talk we discuss these questions from both a containers advocate and serverless fanboy viewpoints. We confront these two approaches, show the differences, individual strengths and weaknesses and where they complement each other. This talk will also discuss motivations from different involved parties so that the audience can build their conclusion. Vaclav Pavlin (Containers & OpenShift guru): Containers will rule the world!. Matthias Luebken (Developer tools PM): Serverless is the Visual Basic for the cloud-native generation.

Let’s see what it takes to build an automated testing/QA setup with Kubernetes and GitLab from scratch, using off-the-shelf components. The goal is to automatically deploy any feature-x or hotfix-x branch to individual environments for automated tests and to make it easier to share intermediate results within the team. This talk will touch on abstract topics like continuous delivery, the value of developer tooling and well-defined workflows, before diving deep into implementation details, learnings, gotchas and stuff-which-went-wrong.

Kubernetes can schedule and manage containers across multiple clusters in different regions through cluster federation. The federation control plane manages deploying replicated applications and services across clusters. It creates a single API and DNS name to discover services running on pods in any federated cluster.

Public, private, and hybrid; software, platform, and infrastructure. A discussion of the current state of the Platform-as-a-Service space, and why the keys to success lie in enabling developer productivity, and providing openness and choice. This presentation considers the success of Open Source in general, looks at the Cloud Foundry project, and explains why Cloud Foundry-based PaaSes are the best places to host your applications written in Java and other JVM-based languages. Presented at GOTO Aarhus 2013

I was invited to give this talk at the Wix Backend Guild Day, an internal event which was broadcast live internationally, on 2018-04-12 Video: https://youtu.be/cQ7UvUybceA These days sbt is the de-facto build tool for Scala, but most of us just write the minimum viable build.sbt file, import the libraries we need (and maybe throw in some sbt-assembly) and forget about it. In this Good Practices session, you will learn about making your build safer and more robust by making the Scala compiler work for you and through using some sbt plugins. This talk will be quite high-level. There will be no need for prior knowledge of sbt and it should be beneficial for you even if you don’t use sbt.

This document provides an introduction to serverless computing and discusses various serverless technologies and concepts. It summarizes Apache OpenWhisk, a serverless platform, and Knative, which provides serverless primitives for container-based applications. It also outlines some benefits and challenges of serverless, including automatic scalability but also deployment complexity. Example use cases like action chaining and event-driven capabilities are demonstrated.

What is DevOps, why do we need it and how do I get started with it? Certainly it is the new buzz world in the world of Agile is "DevOps". This presentation will help you get started with DevOps.

Rackspace uses Chef and other operational tools to automate the deployment of OpenStack. They developed their own cookbooks to model real-world deployments across multiple operating systems and to handle updates and new OpenStack services. Over time, they added capabilities like high availability and vendor integration. To simplify deployment and reduce operator overhead, they created OpenCenter, which automates tasks through a solver and provides an API. OpenCenter lowers the OpenStack knowledge needed by operators.

- The document discusses developments and tools for serverless applications on AWS Lambda. It begins with an overview of new Lambda features like environment variables and Step Functions for orchestrating Lambda functions. - Several serverless frameworks are demonstrated, including the Serverless Framework, Gordon, and Chalice, which simplify developing and deploying Lambda functions and event sources. - The AWS Serverless Application Model (SAM) is presented as a way to bundle Lambda functions, APIs, and events using CloudFormation for simplified deployment. Additional resources on Lambda are also listed.

The use of serverless architecture has very quickly become an accepted approach for organizations deploying cloud applications, with a plethora of choices available for deployment. Even traditionally conservative organizations are making partial use of some serverless technologies. Most of the discussion goes to Functions as a Service (e.g., AWS Lambda, Google Cloud Functions, Azure Functions) while the appropriate patterns for use are still emerging.

The document discusses running containerized Node.js services on AWS Elastic Beanstalk (EB). It provides an overview of Docker containers, AWS, and AWS EB. It describes how to run containerized Node.js microservices on AWS EB, including using Dockerfiles, environment variables, and the AWS EB CLI. It discusses some trade-offs around setup time and costs for using this approach.

In this hands-on lab, you'll learn how to create containerized applications and test them in a Red Hat OpenShift development cluster. You'll quickly develop a basic containerized application, break down an application into multiple containers, and then deploy these images to container host platforms. You’ll get a feel for the different container host platforms and learn how to choose the best one for your container needs. Finally, you’ll understand what to consider and what tools are available when implementing a containerized, microservices architecture.

Plack is an interface for web request handlers that simplifies the interface and makes code more portable. It allows developers to focus on request handling rather than API specifics. Plack addresses issues with traditional CGI and mod_perl approaches by running handlers outside of servers in a standardized way. This encapsulation improves performance, debugging, and code reuse across different server implementations. Plack includes modules for common tasks like routing, middleware, and running PSGI applications on various web servers.

These slides show the latest features and plans for the Eclipse Buildship tooling, which provides Gradle support for the Eclipse IDE

This presentation introduces the Qooxdoo JavaScript framework. Qooxdoo allows building rich desktop-style applications that run in a web browser. The presentation covers the architecture of Qooxdoo applications, the available widgets and layout managers, and demonstrates how to create a simple temperature converter application using test-driven development principles in Qooxdoo. Hands-on exercises guide attendees in using the Qooxdoo tooling and developing a basic user interface.

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.

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