There is a renaissance underway in the messaging space. Due to the demands of IoT networks, cloud native apps, and microservices developers are looking for simple, fast, messaging systems. This is a sharp contrast to how traditional messaging was done.
This webinar will cover:
- The basics of messaging patterns
- What makes NATS unique
- Using a demo inspired by Pokemon Go as an example
A New Way of Thinking | NATS 2.0 & ConnectivityNATS
NATS 2.0 is the largest feature release since the original code base for the server was released. NATS 2.0 was created to allow a new way of thinking about NATS as a shared utility, solving problems at scale through distributed security, multi-tenancy, larger networks, and secure sharing of data. In this presentation, Derek discusses the motives behind the newest features of NATS and how to leverage them to reduce total cost of ownership, decrease time to value, support extremely large scale deployments, and decentralize security to create secure and easy to manage modern distributed systems.
There is a renaissance underway in the messaging space. Due to the demands of IoT networks, cloud native apps, and microservices developers are looking for simple, fast, messaging systems. This is a sharp contrast to how traditional messaging was done.
This webinar will cover:
- The basics of messaging patterns
- What makes NATS unique
- Using a demo inspired by Pokemon Go as an example
Microservices Meetup San Francisco - August 2017 Talk on NATSNATS
Waldemar Quevedo on the NATS team covers why NATS is a great fit as a microservices control plane, and how to build simple, resilient, highly scalable microservices using NATS with the flexible integration patterns it provides.
The Zen of High Performance Messaging with NATS NATS
The Zen of High Performance Messaging with NATS
Waldemar Quevedo Salinas, Senior Software Engineer
NATS is an open source, high performant messaging system with a design oriented towards both being as simple and reliable as possible without at the same time trading off scalability. Originally written in Ruby, and then rewritten in Go, a NATS server can nowadays push over 11M messages per second.
In this talk, we will cover how following simplicity as the main design constraint as well as focusing on a limited built-in feature set, resulted in a system which is easy to operate and reason about, making up for an attractive choice for when building many types of distributed systems where low latency and high availability are very important.
You can learn more about NATS at http://www.nats.io
NATS is a high performance messaging server and also one of the latest additions to the CNCF. In this talk, we will make a deep dive to the internals of the project covering its design, protocol, clustering implementation, security and authorization features that make it an attractive solution for microservices and low latency applications.
A New Way of Thinking | NATS 2.0 & ConnectivityNATS
NATS 2.0 is the largest feature release since the original code base for the server was released. NATS 2.0 was created to allow a new way of thinking about NATS as a shared utility, solving problems at scale through distributed security, multi-tenancy, larger networks, and secure sharing of data. In this presentation, Derek discusses the motives behind the newest features of NATS and how to leverage them to reduce total cost of ownership, decrease time to value, support extremely large scale deployments, and decentralize security to create secure and easy to manage modern distributed systems.
There is a renaissance underway in the messaging space. Due to the demands of IoT networks, cloud native apps, and microservices developers are looking for simple, fast, messaging systems. This is a sharp contrast to how traditional messaging was done.
This webinar will cover:
- The basics of messaging patterns
- What makes NATS unique
- Using a demo inspired by Pokemon Go as an example
Microservices Meetup San Francisco - August 2017 Talk on NATSNATS
Waldemar Quevedo on the NATS team covers why NATS is a great fit as a microservices control plane, and how to build simple, resilient, highly scalable microservices using NATS with the flexible integration patterns it provides.
The Zen of High Performance Messaging with NATS NATS
The Zen of High Performance Messaging with NATS
Waldemar Quevedo Salinas, Senior Software Engineer
NATS is an open source, high performant messaging system with a design oriented towards both being as simple and reliable as possible without at the same time trading off scalability. Originally written in Ruby, and then rewritten in Go, a NATS server can nowadays push over 11M messages per second.
In this talk, we will cover how following simplicity as the main design constraint as well as focusing on a limited built-in feature set, resulted in a system which is easy to operate and reason about, making up for an attractive choice for when building many types of distributed systems where low latency and high availability are very important.
You can learn more about NATS at http://www.nats.io
NATS is a high performance messaging server and also one of the latest additions to the CNCF. In this talk, we will make a deep dive to the internals of the project covering its design, protocol, clustering implementation, security and authorization features that make it an attractive solution for microservices and low latency applications.
NATS & Docker Meetup in Toronto - August 2016
Implementing Microservices with NATS, Diogo Monteiro
-How Aytra uses NATS
-Benefits of using NATS for inter service communication
-Lessons learned adopting NATS
-Overview of Houston NATS library
-Demo of Aytra
You can learn more about NATS at http://www.nats.io
Deploy Secure and Scalable Services Across Kubernetes Clusters with NATSNATS
Services and Streams are the cornerstones of any modern distributed architecture. Communications and observability of modern systems have become just as important as the deployment of the components themselves. In this talk maintainers of the NATS projectwill create a service using NATS as the communication technology. They will show how NATS allows a service application to utilize cutting edge security with the ability to scale up and down, across multiple Kubernetes clusters and cloud deployments. This will be completely observable, with no code changes from the demo code base to global deployment. NATS allows cutting edge modern systems to be built without the additional complexity of load balancers, proxies or sidecars. NATS allows radically easy yet secure deployments across multiple k8s clusters, in any cloud or on-premise environment.
Presentation from a talk given by Diogo Monteiro (@diogogmt) at a recent NATS Meetup in Toronto. The talk covered why NATS is a simple, fast method for microservices communication, and provides some latency benchmarks from Diogo's design of a solution using NATS.
You can learn more about NATS at http://www.nats.io
** Kubernetes Certification Training: https://www.edureka.co/kubernetes-certification **
This Edureka tutorial on "Kubernetes Architecture" will give you an introduction to popular DevOps tool - Kubernetes, and will deep dive into Kubernetes Architecture and its working. The following topics are covered in this training session:
1. What is Kubernetes
2. Features of Kubernetes
3. Kubernetes Architecture and Its Components
4. Components of Master Node and Worker Node
5. ETCD
6. Network Setup Requirements
DevOps Tutorial Blog Series: https://goo.gl/P0zAfF
Simple and Scalable Microservices: Using NATS with Docker Compose and Swarm NATS
NATS is a high-performance messaging system optimized for simplicity, reliability and low latency which can be a lightweight solution for the internal communication of your distributed system. In this talk, we will cover its core feature set as well as how to develop and assemble NATS-based microservices using the latest Docker tooling such as Compose and Swarm mode.
You can learn more about NATS at http://www.nats.io
NATS & Docker Meetup in Toronto - August 2016
Implementing Microservices with NATS, Diogo Monteiro
-How Aytra uses NATS
-Benefits of using NATS for inter service communication
-Lessons learned adopting NATS
-Overview of Houston NATS library
-Demo of Aytra
You can learn more about NATS at http://www.nats.io
Presentation from a talk given by Diogo Monteiro (@diogogmt) at a recent NATS Meetup in Toronto. The talk covered why NATS is a simple, fast method for microservices communication, and provides some latency benchmarks from Diogo's design of a solution using NATS.
You can learn more about NATS at http://www.nats.io
Deploying your first application with KubernetesOVHcloud
Find out how to deploy your first application with Kubernetes on the OVH cloud, and direct questions to the team responsible for our upcoming Kubernetes as-a-Service solution.
Join us to learn the concepts and terminology of Kubernetes such as Nodes, Labels, Pods, Replication Controllers, Services. After taking a closer look at the Kubernetes master and the nodes, we will walk you through the process of building, deploying, and scaling microservices applications. Each attendee gets $100 credit to start using Google Container Engine. The source code is available at https://github.com/janakiramm/kubernetes-101
Kubernetes for Beginners: An Introductory GuideBytemark
An introduction to Kubernetes for beginners. Includes the definition, architecture, benefits and misconceptions of Kubernetes. Written in plain English, ideal for both developers and non-developers who are new to Kubernetes.
Find out more about Kubernetes at Bytemark here: https://www.bytemark.co.uk/managed-kubernetes/
Simple and Scalable Microservices: Using NATS with Docker Compose and SwarmApcera
Waldemar Quevedo, Senior Software Engineer at Apcera
NATS is a high-performance messaging system optimized for simplicity, reliability and low latency which can be a lightweight solution for the internal communication of your distributed system. In this talk, we will cover its core feature set as well as how to develop and assemble NATS-based microservices using the latest Docker tooling such as Compose and Swarm mode.
You can learn more about NATS at http://www.nats.io
The Zen of High Performance Messaging with NATSApcera
The Zen of High Performance Messaging with NATS
Waldemar Quevedo Salinas, Senior Software Engineer
NATS is an open source, high performant messaging system with a design oriented towards both being as simple and reliable as possible without at the same time trading off scalability. Originally written in Ruby, and then rewritten in Go, a NATS server can nowadays push over 11M messages per second.
In this talk, we will cover how following simplicity as the main design constraint as well as focusing on a limited built-in feature set, resulted in a system which is easy to operate and reason about, making up for an attractive choice for when building many types of distributed systems where low latency and high availability are very important.
You can learn more about NATS at http://www.nats.io
NATS & Docker Meetup in Toronto - August 2016
Implementing Microservices with NATS, Diogo Monteiro
-How Aytra uses NATS
-Benefits of using NATS for inter service communication
-Lessons learned adopting NATS
-Overview of Houston NATS library
-Demo of Aytra
You can learn more about NATS at http://www.nats.io
Deploy Secure and Scalable Services Across Kubernetes Clusters with NATSNATS
Services and Streams are the cornerstones of any modern distributed architecture. Communications and observability of modern systems have become just as important as the deployment of the components themselves. In this talk maintainers of the NATS projectwill create a service using NATS as the communication technology. They will show how NATS allows a service application to utilize cutting edge security with the ability to scale up and down, across multiple Kubernetes clusters and cloud deployments. This will be completely observable, with no code changes from the demo code base to global deployment. NATS allows cutting edge modern systems to be built without the additional complexity of load balancers, proxies or sidecars. NATS allows radically easy yet secure deployments across multiple k8s clusters, in any cloud or on-premise environment.
Presentation from a talk given by Diogo Monteiro (@diogogmt) at a recent NATS Meetup in Toronto. The talk covered why NATS is a simple, fast method for microservices communication, and provides some latency benchmarks from Diogo's design of a solution using NATS.
You can learn more about NATS at http://www.nats.io
** Kubernetes Certification Training: https://www.edureka.co/kubernetes-certification **
This Edureka tutorial on "Kubernetes Architecture" will give you an introduction to popular DevOps tool - Kubernetes, and will deep dive into Kubernetes Architecture and its working. The following topics are covered in this training session:
1. What is Kubernetes
2. Features of Kubernetes
3. Kubernetes Architecture and Its Components
4. Components of Master Node and Worker Node
5. ETCD
6. Network Setup Requirements
DevOps Tutorial Blog Series: https://goo.gl/P0zAfF
Simple and Scalable Microservices: Using NATS with Docker Compose and Swarm NATS
NATS is a high-performance messaging system optimized for simplicity, reliability and low latency which can be a lightweight solution for the internal communication of your distributed system. In this talk, we will cover its core feature set as well as how to develop and assemble NATS-based microservices using the latest Docker tooling such as Compose and Swarm mode.
You can learn more about NATS at http://www.nats.io
NATS & Docker Meetup in Toronto - August 2016
Implementing Microservices with NATS, Diogo Monteiro
-How Aytra uses NATS
-Benefits of using NATS for inter service communication
-Lessons learned adopting NATS
-Overview of Houston NATS library
-Demo of Aytra
You can learn more about NATS at http://www.nats.io
Presentation from a talk given by Diogo Monteiro (@diogogmt) at a recent NATS Meetup in Toronto. The talk covered why NATS is a simple, fast method for microservices communication, and provides some latency benchmarks from Diogo's design of a solution using NATS.
You can learn more about NATS at http://www.nats.io
Deploying your first application with KubernetesOVHcloud
Find out how to deploy your first application with Kubernetes on the OVH cloud, and direct questions to the team responsible for our upcoming Kubernetes as-a-Service solution.
Join us to learn the concepts and terminology of Kubernetes such as Nodes, Labels, Pods, Replication Controllers, Services. After taking a closer look at the Kubernetes master and the nodes, we will walk you through the process of building, deploying, and scaling microservices applications. Each attendee gets $100 credit to start using Google Container Engine. The source code is available at https://github.com/janakiramm/kubernetes-101
Kubernetes for Beginners: An Introductory GuideBytemark
An introduction to Kubernetes for beginners. Includes the definition, architecture, benefits and misconceptions of Kubernetes. Written in plain English, ideal for both developers and non-developers who are new to Kubernetes.
Find out more about Kubernetes at Bytemark here: https://www.bytemark.co.uk/managed-kubernetes/
Simple and Scalable Microservices: Using NATS with Docker Compose and SwarmApcera
Waldemar Quevedo, Senior Software Engineer at Apcera
NATS is a high-performance messaging system optimized for simplicity, reliability and low latency which can be a lightweight solution for the internal communication of your distributed system. In this talk, we will cover its core feature set as well as how to develop and assemble NATS-based microservices using the latest Docker tooling such as Compose and Swarm mode.
You can learn more about NATS at http://www.nats.io
The Zen of High Performance Messaging with NATSApcera
The Zen of High Performance Messaging with NATS
Waldemar Quevedo Salinas, Senior Software Engineer
NATS is an open source, high performant messaging system with a design oriented towards both being as simple and reliable as possible without at the same time trading off scalability. Originally written in Ruby, and then rewritten in Go, a NATS server can nowadays push over 11M messages per second.
In this talk, we will cover how following simplicity as the main design constraint as well as focusing on a limited built-in feature set, resulted in a system which is easy to operate and reason about, making up for an attractive choice for when building many types of distributed systems where low latency and high availability are very important.
You can learn more about NATS at http://www.nats.io
Tyler Treat
Workiva
NATS Meetup 3/22/16
• Embracing the reality of complex systems
• Using simplicity to your advantage
• Why NATS?
• How Workiva uses NATS
You can learn more about NATS at http://www.nats.io
NATS: A Central Nervous System for IoT Messaging - Larry McQuearyApcera
Security, identity and scalability define the IoT landscape. Developers in any IoT ecosystem need a flexible, lightweight and secure method to communicate device status/telemetry and content that operates at the speed of a central nervous system and doesn’t rely on inflexible and outdated protocol specifications designed for point-to-point communication. Enter NATS.
NATS is an open source messaging framework based on Go that is designed for simple, secure, lightweight and scalable messaging in any language and for any platform/processor architecture.
Larry McQueary present's an overview and short demonstration on the NATS architecture and API that will demonstrate how NATS can enable “things” and backend infrastructure to communicate securely and scalably at high speed without locking in vendor-specific technology or protocols.
You can learn more about NATS at http://www.nats.io
Patterns for Asynchronous Microservices with NATSApcera
Presentation from a talk by Raul Perez (@repejota) of R3Labs on asynchronous microservices patterns using NATS (@nats_io), the lightweight, high performance open source messaging system written in Go.
You can learn more about NATS at http://www.nats.io
How Greta uses NATS to revolutionize data distribution on the InternetApcera
Dennis Mårtensson is the CTO and co-founder of Greta, a Swedish startup that wants to change the way content is delivered on the internet. Greta has developed a technology for peer-to-peer content delivery over webRTC and are using NATS to create rapid webRTC signaling.
You can learn more about NATS at http://www.nats.io. You can learn more about Greta at https://greta.io/
Micro on NATS - Microservices with MessagingApcera
This is a talk given by Asim Aslam at the NATS London Meetup on May 10th, 2016. It explains what Micro is (Microservices toolkit), and how it uses NATS - a lightweight high performance open source messaging system for microservices, cloud native, and IoT networks written in Golang.
You can learn more about NATS at http://www.nats.io
You can learn more about Micro at https://micro.mu/
NATS - A new nervous system for distributed cloud platformsDerek Collison
NATS is an open-source, high-performance, lightweight cloud messaging system.
NATS was created by Derek Collison, Founder/CEO of Apcera who has spent 20+ years designing, building, and using publish-subscribe messaging systems. Unlike traditional enterprise messaging systems, NATS has an always-on dial tone that does whatever it takes to remain available. This forms a great base for building modern, reliable, and scalable cloud and distributed systems.
Jaime Piña, @variadico, Software Engineer at Apcera
Microservice issues are networking issues. Fixing code in your app is easy, but the hard part of using microservices is the networking. How do you actually know if you're sending what you think you are? Why does this request fail in my app, but not when I use curl? Is this service very slow or is it up at all?
This talk will help demystify some common problems you might experience while building out your collection of microservices. Once you can find the issue, it becomes way easier to fix.
The Zen of High Performance Messaging with NATS (Strange Loop 2016)wallyqs
Video: https://www.youtube.com/watch?v=dYrYCt2dTkw
HTML5: https://wallyqs.github.io/stl-nats-talk/
NATS is an open source, high performant messaging system with a design oriented towards both being as simple and reliable as possible without at the same time trading off scalability. Originally written in Ruby, and then rewritten in Go, a NATS server can nowadays push over 11M messages per second.
In this talk, we will cover how following simplicity as the main design constraint as well as focusing on a limited built-in feature set, resulted in a system which is easy to operate and reason about, making up for an attractive choice for when building many types of distributed systems where low latency and high availability are very important.
IT Modernization Doesn’t Mean You Leave Your Legacy Apps BehindApcera
As enterprises adopt cloud infrastructure and modern architectures, they can’t turn their back on existing applications. The challenge is that legacy applications are expensive-to-maintain and inflexible due to infrastructure requirements and dependencies.
Explore new approaches to application modernization with Mark Thiele, Chief Strategy Officer at Apcera, and Ralph Loura, CTO and Rodan + Fields, to learn how to protect current IT investments and establish a secure path to the cloud.
Over the last few years there has been lot of attention on microservices. After the initial "hype" we saw that what problems it solves and what it can not. I have tried to cover what are microservices and where it can be useful and where it is not. I want to share the guidelines which can be used to choose between a monolith and microservices.
Heb je ook een onderbuik gevoel dat er iets mis is als mensen praten over microservices? Alsof je verplicht bent services te bouwen van hooguit enkele regels code, die expliciet autonoom en los inzetbaar zijn, en altijd via REST moeten communiceren? Iedereen zegt dat je deployment goed op orde moet hebben, omdat dit anders een nachtmerrie wordt, maar niemand geeft een oplossing. In deze sessie geven we je een andere kijk op microservices en hoe je dit ook kunt implementeren binnen je bestaande architectuur.
NGINX Plus R7 is full of new features to help you deliver your applications. HTTP/2 is now fully supported. A redesigned graphical dashboard helps you quickly identify problems. And improvements to the core of NGINX enhance performance, security, and reliability for all your applications. These changes bring tremendous capability to help make your applications faster and more secure than ever.
View full webinar on demand at https://www.nginx.com/resources/webinars/whats-new-in-nginx-plus-r7/
This talk was done in Feb 2020. Sergey and I co-presented at CTO Forum on Microservices and Service Mesh (how they relate, requirements, goals, best practices and how DevOps and Agile has had convergence in the set of features for Service Mesh and gateways around observability, feature flags, etc.)
Ruslan Belkin And Sean Dawson on LinkedIn's Network Updates UncoveredLinkedIn
Ruslan Belkin And Sean Dawson on LinkedIn's Network Updates Uncovered. This was a presentation made at QCon 2009 and is embedded on LinkedIn's blog - http://blog.linkedin.com/
Early Draft: Service Mesh allows developers to focus on business logic while the crosscutting network data layer code is handled by the Service Mesh. This is a boon because this code can be tricky to implement and hard to test all of the edge cases. Service Mesh takes this a few steps further than AOP or Servlet Filters or custom language-specific frameworks because it works regardless of the underlying programming language being used which is great for polyglot development shops. Thus standardizing how these layers work, while allowing teams to pick the best tools or languages for the job at hand. Kubernetes and Istio Service Mesh automate best practices for DevSecOps needs like: failover, scale-out, scalability, health checks, circuit breakers, rate limiters, metrics, observability, avoiding cascading failure, disaster recovery, and traffic routing; supporting CI/CD and microservices architecture.
Istio’s ability to automate and maintaining zero trust networks is its most important feature. In the age of high-profile data breaches, security is paramount. Companies want to avoid major brand issues that impact the bottom line and shrink market capitalization in an instant. Istio allows a standard way to do mTLS and auto certificate rotation which helps prevent a breach and limits the blast radius if a breach occurs. Istio also takes the concern of mTLS from microservices deployments and makes it easy to use taking the burden off of application developers.
This is a small introduction to microservices. you can find the differences between microservices and monolithic applications. You will find the pros and cons of microservices. you will also find the challenges (Business/ technical) that you may face while implementing microservices.
Blue-green deploys with Pulsar & Envoy in an event-driven microservice ecosys...StreamNative
In this talk, learn how Toast leverages our Envoy control-plane to manage blue-green deploys of Pulsar consumers, and how this has helped drive adoption across the engineering organization. Dive into the history of Pulsar at Toast, starting from its introduction in 2019 to provide event-driven architecture across a rapidly scaling restaurant software platform. We will detail some of the hurdles that we encountered gaining buy-in across a diverse set of teams, and dive deep into how we enforce best practices and integrate with our service control plane.
Open Source Bristol 30 March 2022
https://www.meetup.com/Open-Source-Bristol/events/284198269/
18:35 // 'Building a Scalable Event Streaming and Messaging Platform using Apache Pulsar for Fintech' // Tim Spann and John Kinson
Today, companies are adopting Apache Pulsar, an open-source messaging and event streaming platform. Pulsar’s scalability and cloud-native capabilities make it uniquely positioned to meet a range of emerging business needs, including AdTech, fraud detection, IoT analytics, microservices development, and payment processing.
Tim Spann and John Kinson will share insights into the modern data streaming landscape, how Apache Pulsar fits into it, and how it can be used for Fintech. John will also talk about the origins of StreamNative as a Commercial Open Source Software company, and how that has shaped the go-to-market strategy.
AWS re:Invent 2016: Migrating Enterprise Messaging to the Cloud (ENT217)Amazon Web Services
Enterprises rely on messaging to integrate services and applications and to exchange information critical to running their business. However, managing and operating dedicated message-oriented middleware and underlying infrastructure creates costly overhead and can compromise reliability. In this session, enterprise architects and developers learn how to improve scalability, availability, and operational efficiency by migrating on-premises messaging middleware to a managed cloud service using Amazon SQS. Hear how Capital One is using SQS to migrate several core banking applications to the cloud to ensure high availability and cost efficiency. We also share some exciting new SQS features that allow even more workloads to take advantage of the cloud.
Architectural considerations when building an APIRod Hemphill
An properly designed API for either mobile apps or 3rd party access needs to be built with maintainability, security, version control, data volume optimisation and speed performance in mind. Rod Hemphill from Melbourne App Development explains the options and his experience.
Beyond REST and RPC: Asynchronous Eventing and Messaging PatternsClemens Vasters
In this session you will learn about when and why to use asynchronous communication with and between services, what kind of eventing/messaging infrastructure you can use in the cloud and on the edge, and how to make it all work together.
Modern Cloud-Native Streaming Platforms: Event Streaming Microservices with A...confluent
Microservices, events, containers, and orchestrators are dominating our vernacular today. As operations teams adapt to support these technologies in production, cloud-native platforms like Pivotal Cloud Foundry and Kubernetes have quickly risen to serve as force multipliers of automation, productivity and value.
Apache Kafka® is providing developers a critically important component as they build and modernize applications to cloud-native architecture.
This talk will explore:
• Why cloud-native platforms and why run Apache Kafka on Kubernetes?
• What kind of workloads are best suited for this combination?
• Tips to determine the path forward for legacy monoliths in your application portfolio
• Demo: Running Apache Kafka as a Streaming Platform on Kubernetes
OSMC 2016 - Monasca - Monitoring-as-a-Service (at-Scale) by Roland HochmuthNETWAYS
Roland Hochmut ist der Project Tech Lead (PTL) und Software Architect bei Monasca, das Open –Source Monitoring-as-a-Service (at-Scale) OpenStack Project (https://wiki.openstack.org/wiki/Monasca). Er konzentriert sich auf die Entwicklung einer leistungsstarken, skalierbaren und zuverlässigen Turn-Key Monitoring Lösung, die Einfluss hat auf die leitenden Trends und Innovationen der Industrie was Streaming von Daten, Analyse und Big Data betrifft. Er ist auch verantwortlich für die Metrics Processing Pipeline für HP`s öffentliche Cloud. Er hat Erfahrung in mehreren Software-Bereichen und Domänen, sowohl von 3-D Computer Grafiken als auch von Remote Desktop Visualisierung und Cloud Computing und Monitoring.
OSMC 2016 | Monasca: Monitoring-as-a-Service (at-Scale) by Roland HochmuthNETWAYS
Monasca, monasca.io ist eine Turn-Key Open Source OpenStack Monitoring-as-a-Service Plattform, die Authentifizierung und multi-Tenancy mittels OpenStack Keystone Identity Service unterstützt. Monasca ist eine hoch skalierbare, leistungsfähige und Fehler-tolerante Monitoring-as-a-Service Lösung, die Push-based Streaming-Metrics, Gesundheit/Status, Alarmierung/Thresholding und Benachrichtigungen unterstützt. Logging-as-a-Service befindet sich in der Entwicklung, und das Ziel ist es eine umfassende und integrierte Monitoring Lösung für Open Stack Clouds zur Verfügung zu stellen, die auch Kennzahlen, Events und Logs unterstützt.
View On-Demand http://ecast.opensystemsmedia.com/403
Repeat Success, Not Mistakes; Use DDS Best Practices to Design Your Complex Distributed Systems
RTI Connext DDS is a powerful tool that lets you efficiently build and integrate complex distributed systems like no other technology – if you use it right. Be aware of how to get the most out of DDS and how to avoid common pitfalls when developing your system. We've developed RTI Connext best practices over the course of hundreds of customer projects and many years. In this webinar, you will learn how to apply the best practices we have developed to use RTI Connext DDS in ways that will enable your system to scale effectively with optimal performance, while avoiding missteps that will cause poor performance, non-determinism and scalability problems.
The Context package has been a popular topic in the Golang community for sometime and as of the Go 1.7 release, it has become a standard Go library. It carries a variety of details across API boundaries and between processes.
NATS is an open-source, high-performance, lightweight cloud native messaging system. Many NATS users working in Go have been using Context alongside NATS, but there has not been an officially-supported Context-NATS integration – that is, until now.
This talk will discuss what Context is, what observations and lessons Waldemar and his team have learned integrating Context and NATS, and how you use the two together. He'll also provide a quick demo to show the integration.
About the Speaker:
Waldemar Quevedo is a Senior Software Engineer at Apcera, where he develops the Apcera Trusted Platform and is part of the NATS team. Previously, he formed part of the PaaS team at Rakuten in Tokyo which was one of the early adopters of CloudFoundry for production usage where he experienced operating NATS for the first time, and became a fan of its simplicity.
You can learn more about NATS at http://www.nats.io
How Clarifai uses NATS and Kubernetes for Machine LearningApcera
Clarifai (www.clarifai.com) is a machine learning company which aims to make artificial intelligence accessible to the entire world.
Their platform allows users to tap into powerful machine learning algorithms while abstracting away the technical minutiae of how the algorithms work and the infrastructure scaling problems of building AI applications from scratch.
Clarifai has moved to a highly available Kubernetes (www.kubernetes.io) based architecture, which also required a simple, scalable messaging layer.
NATS (www.nats.io) was selected by the Clarifai team for a variety of reasons.
The video of the talk that accompanies these slides is available at:
https://www.youtube.com/watch?v=fJ20plWSBzw&feature=youtu.be
The simple goal of this presentation is to help IT staff make more informed decisions about the how and why of modernizing ITs ability to deliver services.
Presentation by Mark Thiele, Chief Strategy Officer, Apcera
https://www.apcera.com/
At the NATS June Meetup in Boulder, CO, Steven Osborne and Charlie Strawn of Workiva present the Actor Model concept their team are using, and some of the work they are doing to connect NATS and Akka.
You can learn more about NATS at http://www.nats.io
At the NATS June Meetup in Boulder, CO, Colin Sullivan (Principal Engineer on the NATS team) gives an overview of NATS, the NATS Connector Framework, and how to get started building connectors for NATS.
You can learn more about NATS at http://www.nats.io
Simple Solutions for Complex Problems - Boulder MeetupApcera
At the NATS June Meetup in Boulder, CO, Tyler Treat of Workiva gives and updated talk on how to embrace simplicity to solve complex infrastructure problems, and how shares more information on how Workiva uses NATS for microservices communication.
You can learn more about NATS at http://www.nats.io
How to Migrate to Cloud with Complete Confidence and TrustApcera
Henry Stapp, Director of Product Management at Apcera, explores the promises of the cloud and how new technologies (containers, micro-services, etc.) enable unparalleled speed and flexibility.
KURMA - A Containerized Container Platform - KubeCon 2016Apcera
Kurma is a container runtime that is based on the container instrumentation built into the Apcera Platform. Kurma, and its accompanied “KurmaOS” is our vision of a lightweight, fully containerized operating system.
This presentation will cover Apcera’s journey in its container
instrumentation. Beginning with the pre-Docker landscape, how it grew over the course of 3+ years, and the “next-gen” adaption of it, where the base container instrumentation has been adapted to stand on its own, and growing it to be used beyond just Apcera’s own usage.
Kurma incorporates a lot of lessons learned with both development and operations of a container platform, including building modular vs monolith, extensibility being built in vs built on, and managing a cluster of hosts and containers.
We’ll also cover our experiences with introducing it to Kubernetes as another first class runtime provider. Taking how Kurma works and have it work with Kubernetes, and how we’d like to see Kubernetes grow in some of the areas we see Kurma growing.
Integration Patterns and Anti-Patterns for Microservices ArchitecturesApcera
Integration Patterns and Anti-Patterns for Microservices Architectures
David Williams
Co-Founder and Partner, Williams Garcia
You can learn more about NATS at http://www.nats.io
Policy-based Cloud Storage: Persisting Data in a Multi-Site, Multi-Cloud WorldApcera
Apcera's Earl Ruby discusses the role of policy in cloud storage, microservices and container management at SF Microservices meetup. As organizations are building storage and infrastructure at scale, policy supports provisioning, security, performance and business logic.
What problems are we trying to solve?
Define “Scale”...
Cloud software has to to "play nice with others"
Policy for Provisioning, Security, Performance, and Business Logic
You can learn more about The Trusted Cloud Platform at: https://www.apcera.com/
Integration Patterns for Microservices ArchitecturesApcera
One of the fundamental principals of microservices is the idea of lightweight, composable loosely coupled applications that can either talk through some type of service endpoint, through some protocol like HTTP or through pipes.
A lightweight messaging system such as NATS is a better way for microservices to talk to each other and integrate disparate systems outside the microservice or architecture.
You can learn more about NATS at http://www.nats.io
NATS was created by Derek Collison, founder and CEO
of Apcera, who has spent 20+ years designing, building, and using publish-subscribe messaging systems.
Unlike traditional enterprise messaging systems, NATS has an always-on dial tone that does whatever it takes to remain available. Learn how end users are building modern, reliable and scalable cloud and distributed systems with NATS.
Talk given by David Williams, Principal, Williams & Garcia
You can learn more about NATS at http://www.nats.io
Apcera reviews the good, bad and the amazing, based on feedback collected from 250+ early adopters, of emerging microservices platforms and best practices.
You can learn more about The Trusted Cloud Platform at: https://www.apcera.com/
Apcera: Agility and Security in Docker DeliveryApcera
Post Dockercon 2015 Technical Talk on Agility and Security in Docker Delivery
You can learn more about The Trusted Cloud Platform at: https://www.apcera.com/
Delivering Policy & Trust to the Hybrid CloudApcera
Enterprises are turning to the hybrid cloud to drive greater scalability and cost-effectiveness. But enterprises should beware, as the definition of “policy” varies wildly. Some say it’s the ability to control the resources apps’ use or where the apps run. Others view policy as governing the permissions and delivering security. Policy is all of that and more.
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Search and Society: Reimagining Information Access for Radical FuturesBhaskar Mitra
The field of Information retrieval (IR) is currently undergoing a transformative shift, at least partly due to the emerging applications of generative AI to information access. In this talk, we will deliberate on the sociotechnical implications of generative AI for information access. We will argue that there is both a critical necessity and an exciting opportunity for the IR community to re-center our research agendas on societal needs while dismantling the artificial separation between the work on fairness, accountability, transparency, and ethics in IR and the rest of IR research. Instead of adopting a reactionary strategy of trying to mitigate potential social harms from emerging technologies, the community should aim to proactively set the research agenda for the kinds of systems we should build inspired by diverse explicitly stated sociotechnical imaginaries. The sociotechnical imaginaries that underpin the design and development of information access technologies needs to be explicitly articulated, and we need to develop theories of change in context of these diverse perspectives. Our guiding future imaginaries must be informed by other academic fields, such as democratic theory and critical theory, and should be co-developed with social science scholars, legal scholars, civil rights and social justice activists, and artists, among others.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Essentials of Automations: Optimizing FME Workflows with Parameters
NATS for Modern Messaging and Microservices
1. NATS for Modern Messaging and
Microservices
Presented by Alberto Ricart, Principal Engineer, NATS
2. •Community and Ecosystem Manager, NATS.io
• Ways to get involved in NATS Community:
- http://nats.io/community/
Brian Flannery
@brianflannery
brian.flannery@apcera.com
3. •Principal Engineer at Apcera
•Previously with
- TIBCO > 15 years
- Informatica
•Building messaging based systems > 20 years
Alberto Ricart
@alberto.ricart
alberto.ricart@apcera.com
4. - Learn/review messaging basics
- Use messaging patterns
- Describe a sample microservices application
‣ See how NATS and messaging features help us make our services better
What this webinar will cover
6. ๏ Messages - are the unit of data exchange
๏ Producers - send messages to the server
๏ Consumers - receive messages from the server
๏ Messaging Server - distributes messages from producers to consumers
Messaging architecture
7. ๏Have a subject that describes the message contents
๏A payload
{location: {lat: 45.678, lng: 123.456}}
Messages
8. ๏Subject names are extremely important
‣ They specify the destination of the message
Pokenats.eden-service.12.hb.1234
๏They consist of one or more elements (tokens) separated by dots
‣ The elements can be used to create a subject name hierarchies
‣ Individual elements can be thought of as metadata which a service could use
while processing the message
What’s in a subject?
9. ๏Send messages to the server under a specific subject - ‘publishers’
๏Don’t assume the audience of the message
‣ Don’t care who consumes the message
๏A publisher may specify an optional “reply” subject to change the meaning of the
message
Producers
10. ๏ Subscribe to receive messages matching a subscription
๏ Can specify a queue group name
‣ Single member of a queue group is chosen randomly to receive the message
๏ Can specify how many messages to receive before auto-canceling
• This is a big deal
Consumers
11. ๏ Subscribers can specify wildcards
pokenats.eden-service.>
pokenats.*.*.hb.100
๏ ‘*’ matches any value in that element
๏ ‘>’ matches all elements that follow
‣ ‘>’ is only valid at the end of the subject
Subscription wildcards
12. ๏ Highly performant, extremely light-weight
๏ Clustered servers/cluster-aware clients
‣ Built-in resiliency and high availability
๏ Text-based protocol (payload is an array of bytes)
‣ Use telnet to explore
๏ Monitorable on a dedicated port - returning JSON data describing the state of the
server
NATS server features
Chart source: http://bravenewgeek.com/dissecting-
message-queues/
13. ๏ Server protects itself first
‣ Auto-pruning of slow/non-responsive clients
‣ Disconnects clients that send bad protocol messages
๏ At most once delivery
๏ Client APIs for many languages
‣ Community contributed: Spring, Lua, PHP, Python, Scala, Haskel, C#
MyNatsClient
‣ Easy to develop a client. Get involved!
NATS server features (Cont.)
14. ๏ Provides additional features, built on top of NATS
‣ Clients publish to a streaming server
‣ Messages stored until number or size limits are reached
‣ Subscribers can request messages sent earlier
• Start with first/last/n-th/etc message
‣ Durable subscriptions
• Resume previous session
‣ At least once delivery
NATS streaming
17. ๏ Basic messaging pattern
‣ A producer publishes a message with a
specific subject
‣ All active consumers with subscriptions
matching the subject receive it
Publish-Subscribe 1-N
18. ๏ It’s a publish-subscribe operation
‣ Consumers subscribe using a shared queue group
name
‣ A publisher sends a message
‣ The messaging server forwards to single
subscriber
‣ Non members of the queue group will get message
as standard pub-sub
‣ Multiple queue group names subscribers on the
same subject are possible
Queueing 1-1
(Subscribers using a shared queue group name)
19. ๏ Producer creates a subscription to an
unique subject name (a.k.a. reply subject)
‣ Sets max number of messages to
receive
๏ The producer publishes a message with the
reply subject
๏ Subscribers receive the message and
publish a response to the reply subject
๏ Very efficient 1:1 of very large N
Request Reply 1-N
20. ๏ Similar as before, but this time subscribers are
part of a queue group name
‣ Only one subscriber will get the request
Request Reply 1:1
21. ๏ You can build massively scalable services, and achieve many features which would
require a lot effort otherwise
‣ Addressing
‣ Discovery
‣ Control plane
‣ Load balancing
‣ Fault-tolerance
‣ Location transparency
With these simple messaging patterns
22. ๏ Use messaging for inter-service communication
‣ pub/sub, queuing, request/reply
๏ Broadcast heartbeats and health information
๏ Use control plane services to listen to service heartbeats
‣ Add, grow, shrink service queues based on health
๏ Adapt data exchanged by services
‣ Reduce integration points from 1 to N-1 to N
Microservices + messaging
23. Case Study: PokéNATS
Presented by Alberto Ricart, Principal Engineer, NATS
Small study describing how to a create simple and
highly scalable service with NATS messaging
24. Let’s put to work what we have learned...
• Design a small service oriented application
• Could have millions of users?
• Will release as a minimum viable product (many features tbd)
• How would you develop it?
- If you made it with HTTP and REST services would it scale?
- How would you manage it?
- How would you scale it?
- How would you cope with new features, changes and their deployment?
25. Take something seemingly simple like, Pokémon Go!
• Hugely popular augmented reality phone game that
launched in July 2016 based on Pokémon
• Players walk around and:
- Find Pokéstops near them
- Collect Pokémon pets found in the wild
- Level and evolve the pets to make them more powerful
- Battle their pets against other player’s
26. At its core
• It’s a massive sensor collector
- Operates in a very large playground
‣ Every few seconds new location information sent to one or more servers
‣ Every once in awhile, some game event happens
• One million players contributing sensor data every 5 seconds means:
‣ 12 million/min interactions just for the sensor information functionality
27. Being successful sometimes creates nightmares
•Imagine 130+ million downloads (Wikipedia number)
- A little times a lot in cloud scale is huge
- Any application is non-trivial at 1/1000 the success
‣ Performance
• Authentication
• Data persistence
• Business logic
‣ Monitoring & Management
29. Scalability
•Queue group names allow load balancing of services
•Filtering on the subject name enables services to divide work (perhaps with
locality)
•Subscriptions from trainers filter updates and notifications from clients that are
not geographically near
•Request reply services could delay responding based on memory/cpu presure
30. Service Discovery
•Control service uses pokenats_admin.cmd.s_type.sid.discover required
sevices
•Missing services are spawned by the control service
•Filtering enables limiting the impact of a request based on a subject name
31. Fault-tolerance
• If more than one service, it is fault tolerant
‣Auto-heals when new services are added
• NATS can be configured in cluster mode
- Clients randomly connect to servers in the cluster to distribute connections
- Clients switch to a different server if their current connection fails
•Control service reacts to current information by adding and pruning
33. Monitoring
•Log messages are sent under info/error monikers
•Heartbeats tell if services are alive and quantify their health
•Misbehaving clients (or attacks) are logged by re-publishing invalid requests
35. Future Changes
• Loosely coupled makes it easier
- Adding new services doesn’t affect the existing
- Easy to hot test new revs
‣Start a new service alongside the old
•If the new service is observed to work as desired, start more, stop the
old
•If the new service misbehaves, send a control command to kill it
‣By using queue subscriptions only 1/N clients are affected
‣Incremental deployments prevent embarrassing issues
•Integrating a new system?
- If data needs adapting, add a service to do translation!
36. Take-away
• Message-driven micro-services are:
- Better
- Smaller
- Highly scalable
- More manageable
- Able to cope with change and innovation
•More importantly, with careful patterns and design
- Code is usually simpler
- Robust - more resilient