The Istio service mesh is a powerful tool for building a service mesh. If you don’t know about Istio yet, have a look at the Introduction to Istio series of articles or download the ebook Introducing Istio Service Mesh for Microservices.
The power of Istio comes with the cost of some complexity at configuration and runtime. To help this, the Kiali project provides observability of the mesh and the services in the mesh. Kiali visualizes the mesh with its services and workloads. It indicates the health of the mesh and shows hints about applied configuration options. You can then drill in on individual services or settings to view details.
This post describes how to use Kiali to observe what the microservices in your Istio service mesh are doing, validate the Istio configuration, and see any issues.
Continue reading “Observe what your Istio mesh is doing with Kiali”
Have you ever wondered why you are deploying your multi-platform applications using containers? Is it just a matter of “following the hype”? In this article, I’m going to ask some provocative questions to make my case for Why Kubernetes is the new application server.
You might have noticed that the majority of languages are interpreted and use “runtimes” to execute your source code. In theory, most Node.js, Python, and Ruby code can be easily moved from one platform (Windows, Mac, Linux) to another platform. Java applications go even further by having the compiled Java class turned into a bytecode, capable of running anywhere that has a JVM (Java Virtual Machine).
The Java ecosystem provides a standard format to distribute all Java classes that are part of the same application. You can package these classes as a JAR (Java Archive), WAR (Web Archive), and EAR (Enterprise Archive) that contains the front end, back end, and libraries embedded. So I ask you: Why do you use containers to distribute your Java application? Isn’t it already supposed to be easily portable between environments?
Continue reading “Why Kubernetes is The New Application Server”
For developers working on a Kubernetes-based application environment such as Red Hat OpenShift, there are a number things that need to be considered to fully take advantage of the significant benefits provided by these technologies, including:
- How do I communicate with the orchestration layer to indicate the application is operating correctly and is available to receive traffic?
- What happens if the application detects a system fault, and how does the application relay this to the orchestration layer?
- How can I accurately trace traffic flow between my applications in order to identify potential bottlenecks?
- What tools can I use to easily deploy my updated application as part of my standard toolchain?
- What happens if I introduce a network fault between my services, and how do I test this scenario?
These questions are central to building container-native solutions. At Red Hat, we define container-native as applications that conform to the following key tenets:
- DevOps automation
- Single concern principle
- Service discovery
- High observability
- Lifecycle conformance
- Runtime confinement
- Process disposability
- Image immutability
This may seem like a lot of overhead on top of the core application logic. Red Hat OpenShift Application Runtimes (RHOAR) and Istio provide developers with tools to adhere to these principles with minimal overhead in terms of coding and implementation.
In this blog post, we’re specifically focusing on how RHOAR and Istio combine to provide tools for DevOps automation, lifecycle conformance, high observability, and runtime confinement.
Continue reading “Building Container-Native Node.js Applications with Red Hat OpenShift Application Runtimes and Istio”
You’re in an IT department. How does the rest of the organization see you? As a valuable asset whose code and APIs make a difference in the marketplace, or as a necessary evil that should be trimmed as much as possible? Containers, microservices, and serverless computing can make you more responsive, flexible, and competitive, which in turn makes your organization more effective. And that puts you solidly in the asset column.
After sprinting through the streets of San Francisco from the stage of the opening keynote at Red Hat Summit 2018 (replay available here), Burr Sutter hosted a packed house in Moscone South to talk about these technologies. Containers are widely accepted (see the announcement from Red Hat and Microsoft for an example), microservices are increasingly popular as an approach to modernizing monolithic applications, and serverless computing is emerging as an important new programming model.
Continue reading “Red Hat Summit: Containers, Microservices, and Serverless Computing”
[Cross posted from the OpenShift blog]
About a year ago Red Hat announced its participation as a launch partner of the Istio project, a service mesh technology that creates an application focused network that transparently protects the applications from abnormalities in environments. The main goals of Istio are enhancing overall application security and availability through many different capabilities such as intelligent routing, circuit breaking, mutual TLS, rating, and limiting among others. Ultimately Istio is about helping organizations develop and deploy resilient, secure applications and services using advanced design and deployment patterns that are baked into the platform.
As part of our investments in making the technology easily consumable to Kubernetes and OpenShift users, Red Hat has created a ton of content:
- learn.openshift.com: A web-based OpenShift and Kubernetes learning environment where users get to interact through the web browser with a real running instance of OpenShift and Istio service mesh with zero install time and no sign-up required.
- Istio tutorial: Want to try the web-based scenario yourself from scratch? This Git repo contains instructions on how to set up an environment for yourself.
- Introducing Istio Service Mesh for Microservices book by Christian Posta and Burr Sutter
- Blog posts on the OpenShift and Red Hat Developer blogs
Continue reading “Getting Started with Istio and Jaeger on Your Laptop”
The past nine weeks of blog posts have introduced, explained, and demonstrated some of the many features of the Istio service mesh when combined it is with Red Hat OpenShift and Kubernetes. This, the final post in this series, is a recap.
[This is part ten of my ten-part Introduction to Istio series. My previous article was Part 9: Istio Egress: Exit Through the Gift Shop.]
Week one was an introduction to the concept of a service mesh. The concept of a Kubernetes sidecar container was explained and diagrammed, and it was the beginning of a constant theme throughout the blog posts: You don’t have to change your source code.
Continue reading “Istio Service Mesh Blog Series Recap”
Using Istio with Red Hat OpenShift and Kubernetes makes life with microservices easier. Tucked away inside of Kubernetes pods, using the Istio service mesh, your code can run (mostly) in isolation. Performance, ease-of-changes, tracing, and so on are made available by simply using the Istio sidecar container model. But what if you want your microservice to talk to another service that is outside of your OpenShift/Kubernetes/pods environment?
Enter Istio Egress.
[This is part nine of my ten-part Introduction to Istio series. My previous article was Part 8: Istio Smart Canary Launch: Easing into Production.]
Continue reading “Istio Egress: Exit Through the Gift Shop”
Cloud-native application development is the new paradigm for building applications and although is it often mistaken for microservices, it is much more than that and encompasses not only the application architecture but also the process through which applications are built, deployed, and managed.
New apps are often seen as the focus of cloud-native applications; however, we believe existing and new applications are alike and can incorporate cloud-native practices if they have the four defining characteristics of cloud-native applications:
- Service-based: Build modular loosely coupled services (for example, microservices).
- API-driven: Expose services via lightweight technology-agnostic APIs.
- Containers: Package and deploy in containers as a portable unit of compute.
- DevOps: Adopt agile and DevOps principles.
The Getting Started with Cloud-Native Apps lab at Red Hat Summit 2018, which takes place in San Francisco on May 8–10, has a packed agenda that focuses on walking participants through the principles of building and operating cloud-native applications.
Continue reading “Red Hat Summit Spotlight: Getting Started with Cloud-Native Apps Lab”
Burr Sutter (@burrsutter) and I (@christianposta) have finished writing a small book to help folks get up and running with Istio.io service mesh!
Many many thanks to all of the reviewers who took the time to give feedback and to Red Hat for sponsoring my time—especially Burr Sutter and the talented folks at O’Reilly who helped coordinate the effort and make it come to fruition.
Download the complimentary e-book at developers.redhat.com.
The book covers the following topics:
Continue reading “Our Book Has Been Released! Introducing Istio Service Mesh for Microservices”
First to fall over when the atmosphere is less than perfect
Your sensibilities are shaken by the slightest defect
You live your life like a canary in a coalmine…
When Sting and The Police sang those lyrics, I doubt they had microservices, Istio, Kubernetes, and OpenShift in mind. Yet here we are, years later, using the Canary Deployment pattern to ease code into production.
[This is part eight of my ten-week Introduction to Istio series. My previous article was Part 7: Istio Dark Launch: Secret Services.]
Continue reading “Istio Smart Canary Launch: Easing Into Production”