Red Hat simplifies container development and redistribution of Red Hat Enterprise Linux packages

Red Hat simplifies container development and redistribution of Red Hat Enterprise Linux packages

Now, application developers in the Red Hat Technology Partner program can build their container apps and redeploy from the full set of Red Hat Enterprise Linux (RHEL) user space packages (non-kernel). This nearly triples the number of packages over UBI only.

When we introduced Red Hat Universal Base Images (UBI) in May 2019, we provided Red Hat partners the ability to freely use and redistribute a substantial number of RHEL packages that can be deployed on both Red Hat and non-Red Hat platforms. This gave developers the ability to build safe, secure, and portable container-based software that could then be deployed anywhere. The feedback on this has been overwhelmingly positive and we thank you for it, but we learned that you needed more, so we’re sharing this advanced preview with Red Hat Partner Connect members to help you with your planning. 

Expanded and exclusive redistribution rights for Red Hat Technology Partners

We are pleased to announce expanded partner terms and conditions that grant Red Hat Technology Partners free use and redistribution rights to all Red Hat Enterprise Linux user space packages when you build upon UBI-based images. With more than triple the number of RHEL packages now available, you can simplify your container and Operator development and freely re-distribute your container-based software through both Red Hat and non-Red Hat registries. This is only available to Red Hat partners who participate in and complete Red Hat Container Certification.

Continue reading “Red Hat simplifies container development and redistribution of Red Hat Enterprise Linux packages”

Share
Speed up Maven builds in Tekton Pipelines

Speed up Maven builds in Tekton Pipelines

Tekton is an open source project that provides standard Kubernetes-style resources and building blocks for creating CI/CD pipelines that can run on any Kubernetes. Tekton does this by introducing a number of custom resource definitions (CRD) such as Pipeline, Task, and ClusterTask to provide a language and structure for defining delivery pipelines as shown in Figure 1. Tekton also provides a set of controllers that are responsible for running pipelines in pods on demand whenever a user creates an aforementioned resource.

Diagram of a Pipeline containing a Task workflow.

Figure 1: A Tekton pipeline contains a sequence of tasks.

The use of Tekton has grown rapidly over the last year. One of the frequently requested features is the ability to share artifacts between tasks in order to cache dependencies for build tools such as Maven and NPM. Although it was possible previously to use volumes in tasks, the release of Tekton 0.10 adds support for workspaces, which makes it easier for tasks within a pipeline to share artifacts using a persistent volume.

In this article, we look at how workspaces can be used to cache Maven dependencies in Java builds in order to remove the need to download dependencies for each build.

Continue reading “Speed up Maven builds in Tekton Pipelines”

Share
How to ignore files in Git without .gitignore

How to ignore files in Git without .gitignore

Git has a handy feature when it comes to preventing accidental file check-ins when the files are meant to stay local. The obvious candidates are compiled binaries when you only want to check in the source code. Other candidates are files with local configurations.

One can put all of those files and paths into a .gitignore file in the project. To persist those changes (and to share the common file contents with collaborators on the project), one usually adds the .gitignore file to Git like any other file in the project.

The problem

Unfortunately, there are limits to this approach.

Continue reading “How to ignore files in Git without .gitignore”

Share
C# 8 asynchronous streams

C# 8 asynchronous streams

.NET Core 3.1 (December 2019) includes support for C# 8, a new major
version of the C# programming language. In this series of articles,
we’ll look at the new features in .NET’s main programming language. This first article, in particular, looks at asynchronous streams. This feature makes it easy to create and consume asynchronous enumerables, so before getting into the new feature, you first need to understand the IEnumerable interface.

Note: C# 8 can be used with the .NET Core 3.1 SDK, which is available on Red Hat Enterprise Linux, Fedora, Windows, macOS, and on other Linux distributions.

A brief history of IEnumerable

The classic IEnumerable<T> has been around since .NET Framework 2 (2005). This interface provides us with a type-safe way to iterate over any collection.

The iteration is based on the IEnumerator<T> type:

Continue reading “C# 8 asynchronous streams”

Share
Designing an event-driven process at scale: Part 3

Designing an event-driven process at scale: Part 3

In the first article in this series, Designing an event-driven business process at scale: A health management example, Part 1, you found the business use case and data model for a concrete example from the health management industry. You then began implementing the example in jBPM (an open source business automation suite) by creating the Trigger process.

In the second article, you implemented the Task subprocess and, among other things, you also configured the call parameters for the Reminder and Escalation subprocesses within the Task subprocess. Now you will implement these subprocesses.

Continue reading “Designing an event-driven process at scale: Part 3”

Share
Designing an event-driven process at scale: Part 2

Designing an event-driven process at scale: Part 2

In the first article in this series, Designing an event-driven business process at scale: A health management example, Part 1, we began by defining the business use case and data model for a concrete example from the health management industry. We then began implementing the example in jBPM (an open source business automation suite) by creating our trigger process.

Now, in the second article in this series, we will focus on creating the Task subprocess and its many components. In our case, these are:

  • The Expired? gate
  • The Suppressed? gate
  • The human task
  • The Reminder subprocess
  • The “What type of close?” gate
  • The Hard Close embedded subprocess
  • The Escalation subprocess

Continue reading “Designing an event-driven process at scale: Part 2”

Share
Designing an event-driven business process at scale: A health management example, Part 1

Designing an event-driven business process at scale: A health management example, Part 1

The concept of a business process (BP), or workflow (WF), and the discipline and practice of business process management (BPM) have been around since the early 90s. Since then, WF/BPM tools have evolved considerably. More recently, a convergence of different tools has taken place, adding decision management (DM) and case management (CM) to the mix. The ascendance of data science, machine learning, and artificial intelligence in the last few years has further complicated the picture. The mature field of BPM has been subsumed into the hyped pseudo-novelties of digital business automation, digital reinvention, digital everything, etc., with the addition of “low code” and robotic process automation (RPA).

A common requirement of business applications today is to be event-driven; that is, specific events should trigger a workflow or decision in real-time. This requirement leads to a fundamental problem. In realistic situations, there are many different types of events, each one requiring specific handling. An event-driven business application may have hundreds of qualitatively different workflows or processes. As new types of events arise in today’s ever-changing business conditions, new processes have to be designed and deployed as quickly as possible.

Continue reading “Designing an event-driven business process at scale: A health management example, Part 1”

Share
Metrics and traces correlation in Kiali

Metrics and traces correlation in Kiali

Metrics, traces, and logs might be the Three Pillars of Observability, as you’ve certainly already heard. This mantra helps us focus our mindset around observability, but it is not a religion. “There is so much more data that can help us have insight into our running systems,” said Frederic Branczyk at KubeCon last year.

These three kind of signals do have their specificities, but they also have common denominators that we can generalize. They could all appear on a virtual timeline and they all originate from a workload, so they are timed and sourced, which is a good start for enabling correlation. If there’s anything as important as knowing the signals that a system can emit, it’s knowing the relationships between those signals and being able to correlate one with another, even when they’re not strictly of the same nature. Ultimately, we can postulate that any sort of signal that is timed and sourced is a good candidate for correlation as well, even if we don’t have hard links between them.

Continue reading “Metrics and traces correlation in Kiali”

Share
Continuous integration with GDB Buildbot

Continuous integration with GDB Buildbot

Continuous integration is a hot topic these days, and the GNU Project Debugger is keeping up with the trend. Who better to serve as a role model for tracking and exterminating bugs than a debugger?

The GDB Buildbot started as a pet project back in 2014 but is now an integral part of the development process. It provides an infrastructure to test new commits pushed to the official repository, as well as a service (which we call try builds) for developers to submit their proposed changes. In this article, I share the story of our Buildbot instance, where we are right now in terms of functionality, and the plans (and challenges) for the future.

Continue reading “Continuous integration with GDB Buildbot”

Share