CINQ ICT is door de Cloud Native Computing Foundation uitgeroepen tot Kubernetes Training Partner. Hiermee erkent CNCF dat CINQ zich heeft bewezen als betrouwbare partner voor het geven van Kubernetes trainingen, workshops én examentraining. 

Voor een introductie in Kubernetes of deep-dive in de meest geavanceerde functies staan onze Certified Kubernetes Administrators klaar om organisaties, teams en jou als engineer verder te helpen in de wereld van Kubernetes. We brengen je de basis bij of stomen je klaar voor het Certified Kubernetes Administrator examen of Certified Kubernetes Application Developer examen. 

Door jarenlange ervaring met Kubernetes op enterprise-level, weten onze trainers als geen ander wat belangrijk is om Kubernetes succesvol te implementeren en beheren. De trainers van CINQ zijn CKA en/of CKAD gecertificeerd en brengen met hun praktijkervaring een mooie verdieping aan op de bestaande theorie. Zo weet jij zeker dat je echt wat opsteekt van onze trainingen, en kun je dit ook direct in de praktijk toepassen.

Bekijk het volledige aanbod van onze Kubernetes trainingen of neem contact op voor een training op maat. We helpen je graag!

CINQ ICT is uitgeroepen tot Kubernetes Training Partner in Nederland.

Kubernetes Training Partner

CINQ ICT uitgeroepen tot Kubernetes Training Partner

Op woensdag 11 mei heeft onze managing consultant Bouke Nijhuis op Devoxx UK 2022 mogen spreken over één van zijn favoriete Java tools: de debugger. 

Niet alleen gaf Bouke uitleg en tips, maar tijdens een live demo onthulde hij enkele verborgen pareltjes van de debugger en liet hij zien wat je er precies mee kan. 

remote debugging (why stay on your local machine?)

inline watches (interesting values directly in the code)

hot code swapping (faster than rewriting the code)

stream debugging (for those 'hard to debug' streams)

Natuurlijk willen wij deze tips graag met je delen, mocht je het gemist hebben. 

Zijn jouw debugging skills klaar voor het volgende level? Bekijk dan hieronder de presentatie van Bouke: 'Improving your  skills with the debugger'.

Improving your skills with the debugger by Bouke Nijhuis

Op woensdag 11 mei heeft onze managing consultant Bouke Nijhuis op Devoxx UK 2022 mogen spreken over één van zijn favoriete Java tools: de Debugger. Bij deze delen wij graag de video van zijn presentatie 'Improving your debugging skills'.

Bouke Nijhuis op Devox UK 2022 - Video

Bouke Nijhuis op Devoxx UK 2022 - Video

In this blog, I would like to share something I recently discovered when studying for the Java 11 certification. Strangely enough, it is not a new Java 11 feature. It’s not even something introduced in Java 8 or 7. No, it’s something that's been around since the early days of version 6. It’s the ServiceLoader class. A long-forgotten feature which thanks to the introduction of modules in Java 11 has become especially relevant again.

The ServiceLoader class was first introduced in Java 6. It was used to make applications extensible, so you could add functionality without recompiling the whole application. Basically, the SeviceLoader scans the classpath looking for an implementation of any interface you may want and returns the results, which then can be used at runtime in your code. Essentially, this is a form of dependency injection.

Dependency Injection
What is dependency injection and why is it important? Quality code should adhere to the following design principle:

This principle is not rocket science. It simply means that an object that uses another object should not create that object, but instead receive the objects it is dependent on. This technique is called dependency injection.   

There are many ways of injecting dependencies into objects. 

1 - You could use a framework. There are quite a few dependency injection frameworks Java developers can choose from. For example, Spring Framework or Google Guice are very popular. 

2 - However, a framework is not necessary. There are far simpler techniques for achieving the same goal. There are several methods of dependency injection in Java without the need of leveraging third party frameworks and only rely on simple regular everyday code. The simplest are: 

Constructor injection. The dependencies are injected via constructor parameters. 

Setter injection. After the object has been initialized, setter-methods are used to add the dependency. 

Factory method. Similar to the Constructor injection method, however, the constructor is called with the necessary parameters within a method belonging to a Factory class.  

Factory injection. This is an improvement to the Factory method. By implementing the Factory Pattern. Basically, all the logic needed to initialize the object with all the necessary dependencies are abstracted away within an independent class, a Factory class. This object internally decides which dependencies are needed. 

The main advantages of these methods are that you don’t need to add any external libraries to your build path, nor do you need to use any ‘funny looking’ annotations to tell the framework what needs to be injected and where. It is done in plain old, easy to understand Java code.  

3 - “But I need to dynamically switch between implementations in my code”, I hear you say. Yes, there are some use cases where you may need to load an implementation of a class at runtime. Luckily, that’s not a problem in Java. There is the ServiceLoader class. 

As previously discussed, this class has been around since version 6, and can be found in the java.util package. This class will scan through the classpath or (from version 11) through the module path of your application and retrieve the available implementations. Giving you a Java native way of dynamically loading classes and injecting them into objects. Most probably in conjunction with some kind of Factory class to abstract away some of the code.

Module path
Before we dive further into the workings of the ServiceLoader class, I need to discuss the new module system introduced in Java 11. 

In layman terms, in Java 11 the classpath has been replaced by a module path. Don’t panic, you can still use a classpath, but this is no longer advised. 

The biggest difference between a classpath and the newer module path is that when using a classpath Java searches through all the locations designated on the classpath looking for the class to use. Often, this works fine. However, it is possible to have multiple instances of the same class defined on your path. And because Java has no strict way of traversing through the classpath, your application will randomly use different implementations of a class. Potentially causing all kinds of unpredictable problems, colloquially called “Dependency Hell”.

This has been fixed in the module path way of working. Instead of an unorganized collection of available classes. Classes and packages are now ordered into neatly organized modules. And because modules need to declare which classes they make accessible for other modules and which modules they use; java has the ability to validate all modules loaded at compile time helping to prevent dependency hell. 

The ‘exports’ keyword is used for making packages available and the keyword ‘requires’ is used for declaring which modules are used. This information is placed in the module-info.java file, which can be found in the source folder.

ServiceLoader
As previously described, the ServiceLoader is able to search the classpath looking for implementations. But how does it work when using a module path? Modules no longer implicitly expose any classes. Therefore, an implementation (also called a Service in Java 11) needs to be exposed to the outside world. This is done by using the keywords ‘provides … with ...’. Also, you need to declare that a module uses an external implementation. This is done by using the ‘uses’ keyword.

Module 1 – The module exposing (exporting) the interface
Module definition

Module 2 – The module providing the service implementation (doesn't need to be exported!)
Module definition

 Module 3 – The module using the service: 
The module definition of a module using a service.

If all the modules have been correctly defined, then using the ServiceLoader is easy. You only really need to know one static method ‘load’ which takes a class as a parameter and returns a collection of Classes. Because the ServiceLoader can retrieve an unknown number of classes, you will have to write some code to determine which class instance (if any) to use.

Summary
To quickly summarize. In many cases of injecting dependencies, we don’t need a framework to get the job done. Java out-of-the-box offers us the tools needed to solve the problem of dependency injection.

In this blog, I would like to share a long-forgotten feature which has become especially relevant again, the ServiceLoader class

The ServiceLoader and Native Dependency Injection in Java 11

Certificaten, cruciaal om je server verkeer te beveiligen. Maar ze staan bij veel mensen ook bekend als probleem-veroorzakers. Eén van de problemen die we bij onze klanten meemaken is dat de certificaten niet tijdig worden vervangen. Met Splunk hebben we een krachtige tool in handen, die we ook voor dit probleem kunnen inzetten.

Een Splunk installatie heeft een aantal standaard componenten. Zo komt Splunk standaard met zijn eigen Python versie, maar ook OpenSSL is een van deze componenten. Met OpenSSL kunnen we certificaten uitlezen en dat maakt het mogelijk om monitoring in te richten.

Het volgende commando kan de start- en einddatum van een certificaat tonen:

splunk cmd openssl x509 -inform pem -noout -startdate -enddate

Om dit te kunnen doen hebben we eerst het certificaat nodig. Indien je certificaten die op de server staan zou willen monitoren, kan je die waarschijnlijk nog wel vinden. Maar deze oplossing is juist zo krachtig omdat je de geldigheid van certificaten kunt monitoren waar jij zelf gebruik van maakt. Om certificaten te tonen van andere servers of applicaties kunnen we het volgende commando gebruiken:

splunk cmd openssl s_client -showcerts -connect cinqict.nl:443

In dit voorbeeld maakt OpenSSL een verbinding met de website van CINQ over poort 443. Op deze manier kunnen allerlei applicaties op verschillende poorten benaderd worden. Combineer deze commando’s, filter wat op de output en je hebt bijvoorbeeld dit commando:

splunk cmd openssl s_client -showcerts -servername cinqict.nl -connect cinqict.nl:443  2>/dev/null | splunk cmd openssl x509 -inform pem -noout -startdate -enddate

notAfter=Apr 11 07:13:54 2022 GMT
notBefore=Jan 11 07:13:55 2022 GMT

De volgende stap die we nu moeten doen, is zorgen dat we hiervan een scripted input maken in Splunk.

Het commando dat we gemaakt hebben zetten we om in een Linux shell script. We zetten de hostname en de poort om in parameter. Het scriptje noemen we: sslcheck.sh. 

echo hostname=$1 port=$2
echo | splunk cmd openssl s_client -showcerts -servername $1 -connect $1:$2 2>/dev/null | splunk cmd openssl x509 -inform pem -noout -startdate -enddate

Vergeet niet het scriptje executable te maken (chmod +x) en probeer het uit:

De output van dit scriptje ziet er als volgt uit:

hostname=cinqict.nl port=443
notBefore=Jan 11 07:13:55 2022 GMT
notAfter=Apr 11 07:13:54 2022 GMT

Als we de output van dit script in Splunk indexeren, kunnen we proactief gaan monitoren! Daar hebben we een zogeheten scripted input voor nodig. Maak in je Splunk home directory in etc/apps een nieuwe app aan: TA_CertificateMonitoring en maak twee subdirectories: bin en local. In de bin directory plaats je het sslcheck.sh script en in de local directory maak je een inputs.conf aan.

[script:///$SPLUNK_HOME/etc/apps/TA_SSLCertificateCheck/bin/sslcheck.sh {hostname} {port}]
index = {indexname}
sourcetype = sslcheck
disabled = false
interval = 43200

Als laatste moeten we de Sourcetype nog definiëren, alle data in Splunk bevat een tijdswaarde. In de output van het script zit alleen de start- en einddatum van het certificaat, niet het tijdstip van monitoren. Daarom voegen we in de Sourcetype definitie toe dat de huidige systeem-tijd hiervoor gebruikt moet worden. In de local directory van de TA maak je een props.conf aan die er alsvolgt uitziet:

[sslcheck]
DATETIME_CONFIG = CURRENT
SHOULD_LINEMERGE = true
NO_BINARY_CHECK = true
BREAK_ONLY_BEFORE = hostname

Zodra we de scripted input hebben aangemaakt en Splunk herstart hebben, is de input actief. Zoek in de index die je in de inputs.conf hebt opgegeven naar de data:


Er zijn meerdere manieren om de einddatum juist in een veld te krijgen. Je kunt hiervoor bijvoorbeeld gebruik maken van een field extraction of een calculated field, waarbij je een EVAL functie kunt gebruiken. In dit voorbeeld lossen we het voor het gemak even op met een reguliere expressie. Vervolgens zetten we het veld om naar een epoch timestamp zodat we dit kunnen vergelijken met de huidige datum tijd.

index=_internal sourcetype=sslcheck hostname=cinqict.nl
| rex "notAfter=(?<enddate>[^\n]+)"
| eval enddate = strptime(enddate, "%b %d %H:%M:%S %Y %Z”)

Nu kunnen we een alert gaan maken die ons twee maanden van te voren informeert, zodat we tijdig het certificaat kunnen verlengen of vervangen.

index=_internal sourcetype=sslcheck hostname=cinqict.nl
| rex "notAfter=(?<enddate>[^\n]+)"
| eval enddate = strptime(enddate, "%b %d %H:%M:%S %Y %Z")
| where enddate < relative_time(now(), "+2m")

Sla deze search op als alert, laat deze dagelijks draaien en mail bijvoorbeeld naar het gehele team. Misschien is er op jouw Splunk omgeving wel een custom alert action gemaakt, waardoor je hier meteen een actie van kunt maken op je sprint planning!

Mocht je na het lezen van deze blogpost vragen hebben over het monitoren van certificaten, neem dan gerust contact met ons op. We denken graag met je mee!

Meer weten over certificaten monitoren en vervangen?

Luister naar onze podcast-aflevering over het geautomatiseerd vervangen van TLS certificaten. 

Lees de blogpost over het geautomatiseerd vervangen van certificaten met Hashicorp Vault en cert-manager.

Splunk kan ingezet worden om de geldigheid van certificaten op je servers te monitoren. Hoe je dit opzet lees je in dit blog.

Certificaten monitoren met Splunk

In this blog I want to give a short introduction into the use of monads in Java. Interestingly, the concept of a monad has been around for quite some time now. Originating in mathematics it’s a design pattern which has previously only been popular in functional programming languages. However, it has found its way to Java. There is even a large chance that you have already been using them unknowingly. Especially, if you have been using the Optional and Stream libraries introduced in Java 8. So, what is a monad and how does it help me write clearer code? 

The Problem
First, I’m going to start with the problem that a monad helps us to solve. Its main goal is to help abstract away boiler plate code that isn’t the main concern of your code. Think of null checking, exception handling, validation, logging, concurrency, etc. 

In this first code block, four classes have been declared. The first three classes represent a bank with customers which in turn may each have an active account. The Bank class has a single method which returns the Customer with the supplied id. The Customer class has a single method which returns the customer’s Account. The Account class also has a single method which returns the balance of the account. The final class ATM has a single method which takes a Bank instance and an id as a parameter and returns an account's balance.

The problem is that the methods in Bank, Customer and Account may return null. The id might not be correct, or the customer may no longer have an account at the bank, or the balance may not be available. This will result in the fetchBalance method of the ATM class throwing a NullPointerException, which will cause the program to crash.

We can fix this by refactoring the fetchBalance method to check if each value returned by Bank, Customer or Account happens to be a nullpointer (Alternative 1). We can all agree that this code works, but it’s not a pleasure to read. Alternatively, you could use nested if-statements to check for not null. However, this also has little effect on the readability of your code (Alternative 2).

 Another alternative (Alternative 3) would be to place the code in a ‘try-catch’. This would improve the readability, but hide the cause of the exception, limiting your ability to later add some code to be able to recover from the exception. 

What is a Monad?
 So, what is a monad and how can it help us write more readable code? A monad is defined as any class (data type), which represents a specific calculation. It must implement at least these two functions:

A function to wrap any basic value, creating a new monad. Also called the return function.

And a function that allows you to perform operations on a wrapped data type (monad). Also called the bind function.

It must also adhere to the following three monad laws:

Left identity, passing an operation to a monad should yield the same result as applying the operation to the original value.

Right identity, passing a wrapper function to a monad should yield the same result as creating a new nomad.

Associativity, when chaining functions, it should not matter how the functions are nested.

The first two identity laws basically say that the only thing the return function is allowed to do is to wrap the object. It cannot manipulate the data in any way.

The final law ensures that it doesn't matter how bind functions are nested, the results are the same. Which simply means that the same sequence of operations will always produce the same value.

In Java the Optional class has all the necessary characteristics of a monad:

Does it represent a specific calculation? Yes, it encapsulated a mechanism for performing actions on values safely without causing a null pointer exception. 

Is there a function for wrapping basic values and creating a new monad? Yes, ofNullable which takes any value and returns a new Optional instance containing that value. 

Does it have a function to allow operations to be performed on its contained value? Yes, flatMap does the trick nicely. 

Does it adhere to the three monad laws? The short answer is yes.

Other commonly used monads found in Java include: Stream<T> (and all the different types of streams) and CompletableFuture<T>.

How do monads solve our problem?
Now that we know what a monad is, let’s use the Optional monad, also known as the Maybe monad in other languages, to clear up our code.


Refactored code using the Optional monad.

We start by changing the return type of the getter methods in the Bank, Customer and Account classes, we do this by using the ofNullable method to wrap the return values. Thanks to the Optional we have also clearly declared that the methods may return null. 

Then, we refactor the ATM's fetchBalance method. First, we wrap the Bank input parameter in the Optional monad. Finally, we use a chain of flatMap calls to perform operations on the wrapped value. Each time calling a getter method to replace the value inside the Optional with a new value. If at any time the value becomes null, any remaining transformations have no effect.

After refactoring, we end up with code that is easier to read and safer to run. The messy null pointer checks have been abstracted away and you are left with a chain of declarative transformations. Not bad.

 And now?
I hope you enjoyed reading this introduction to monads in Java. Now that you have a general idea what a monad is, you should have an easier time following other more in-depth articles, blogs or presentations about this subject.

In this blog I want to give a short introduction into the use of monads in Java.

Monads in Java: a short introduction

Don’t worry! I’m not going to talk about dressing up casually for work as the title may suggest. This is going to be a little story on how, after eight years since introduction, I stumbled into using functional style programming. Apart from using the occasional Java Stream here and there, I never wrote any code in a functional style kind of way. Until now that is…

An important aspect of my current project is logging. One of the requirements we defined for testing is that we want to be able to assert that things are logged correct. The objective was simple. Write a piece of code that can do that in an easy way (and if the code is flexible then that is a plus).

As a huge clean-code fanatic, instead of starting to type relentlessly and crank out the code as I go, I started at the end. How do I want it to look when I use my custom made class? How can I design it in an elegant way?

Asking myself these kinds of questions made me sort of design the code upfront. Which sounds to me like doing the right thing. And while I am at it I might as well throw in some TDD and write a test for my custom LoggerSpy first.

Awesome! Short, concise and it does the job. Although it is clear what LoggerSpy does, it isn’t very flexible. It accepts a string and checks if the list of log events contains a message that exactly matches the given string.

But what if I want to check if the log contains a message that ‘starts’ with a given string? Or ‘ends’ with it? Or complies to a certain regex? Should I make extra public methods in my LoggerSpy for each of those checks? That doesn’t sound overwhelmingly flexible.

My next design attempt was something along the lines of the Hamcrest library. It’s time to introduce the ‘equalTo’ matcher.

Now I could potentially make a matcher for every way I want to match my  log message against a given string. The code reads well, it is flexible, the call to containsMessage is very self-explanatory and it looks nice also. This seems like a good time to start implementing the whole thing.

My first reflex for implementing LoggerSpy was doing it hardcore Java style. None of that functional style voodoo code! (Note: by voodoo code I mean code that seems to work great but you don’t quite understand what it does or how it exactly works) 

Job accomplished. My design is implemented. The usage of the LoggerSpy is clean and simple. But we already knew that since we designed it upfront. The only thing that bugged me was the amount of boilerplate code needed.

1. for each type of matcher (equaITo, startsWith etc.) I had to create a separate class, create a static method that accepts a String value and create a field to store the String value. While actually the only thing that truly matters is this piece of code: 




2. and since I have to create a different class for each type of matcher, I had to create an Interface (LoggerSpyMatcher) as well in order to pass along all my different types of matchers to the containsMessage method.

But altogether a very good attempt. The main goal was easy and flexible in use. Commit-Push. Next story…

A week or so later I accidentally stumbled upon a talk by a software engineer called Mama Samba Braima (aka Nelson). In that talk he explained functional style programming in an easy to follow manner. What first seemed like reading a book written in Chinese started to make some sort of sense to me all of a sudden.

What if I saw functional style programming as a way to create methods that you can pass along to another method and execute it inside that other method when needed? Although this explanation feels like selling the concept of functional style programming a bit short and not telling the whole story, it was a good metaphor that helped me visualize it a bit better. All of a sudden the idea of refactoring my LoggerSpy functional style was born.

If you take a look at the java.util.function package you’ll see all these kinds of interfaces. Consumer, ObjLongConsumer, Supplier, DoubleSupplier, Function, BiFunction, Predicates. There are 43(!) of those guys in there. Not very inviting to read.  

But as it turns out these functional interfaces are basically descriptions of the kind of method that you want to pass. It defines the input parameter(s) and the return type, for instance:

a Function<String, Integer> represents a method that you want to pass which accepts a String as input and returns an Integer as output.

a BiFunction<String, Long, Integer> represents a method that you want to pass which accepts a String and a Long as input and returns an Integer as output.

a Consumer<String> represents a method that accepts a String and returns nothing.

a Supplier<Integer> is the opposite of a Consumer, it accepts nothing but returns an Integer

a Runnable doesn’t accept anything and it also returns nothing. It’s like Nike. It just does something. 

a Predicate<Person> represents a method that accepts a Person object as input and returns a boolean.

There are many more functional interfaces but it is basically all the same.

I read about Functions… and then it clicked…

As you can see in the code example above, my “matches” methods in the non-functional style LoggerSpy  accept a list of ILoggingEvents and return a boolean.

So, for my functional style LoggerSpy to work I need to create matchers of type Predicate<List<ILoggingEvents>>.

That piece of code above looks confusing at first glance. EqualTo returns a LoggerSpyMatcher while events.stream().anyMatch() would return a boolean, huh??? But it is not the value (or the outcome) of the anyMatch method that the equalTo method returns. Nope, it is the “logic” itself that the equalTo method returns.

Looking good, but all I have created up until now are my “methods” that I want to pass to the containsMessage method of the LoggerSpy. I can pass along all the matchers that I want but at this point it doesn’t do anything.


The only thing that I need now is a way to invoke the matcher. That is where the “Single Abstract Method” (SAM for short) of a functional interface comes into play. 

All I have to do now is call the SAM on my matcher object inside my containsMessage method. Calling that method on my matcher invokes the method that I just passed into my containsMessage method and returns a boolean result.

… and I use LoggerSpy in my tests like this

Super clean, simple and easy to use. Never thought that I would end up actually using functional style programming after all this time. But I have to admit… I kinda like it!

The full working example can be found on my GitHub:

https://github.com/vlouisa/logger-spy/tree/feature/functional-style

https://github.com/vlouisa/logger-spy/tree/feature/non-functional-style

Functional style programming - a story of a software engineer who tries it for the first time.

Functional style programming in Java

Oh no! I am going functional style after all this time...

Splunk® IT Service Intelligence (ITSI); De oplossing voor monitoring en analyse, welke aangedreven door machine learning en kunstmatige intelligentie inzicht biedt in de gezondheid van kritieke IT- en zakelijke diensten en hun infrastructuur. 

Een uitleg als bovenstaande, gevolgd door de verschillende usecases die Splunk ITSI vervult is wat ik vooral terugvind op het internet. Wat ik nog weinig zie zijn de ervaringen uit de praktijk of technische how-to’s. Zonde, want na een korte kennismaking met ITSI is vaak de reactie: ‘ziet er super gaaf uit’ – kort gevolgd door – ‘maar wat is er nodig voor de inrichting? Hoe werkt het en/of waar moet ik beginnen?’  

In dit artikel geef ik antwoord op deze vragen en neem ik jullie graag mee naar het startpunt van ITSI, namelijk het aansluiten van een databron. Ik ga wat meer in op de techniek achter de oplossing en laat aan de hand van een praktijkvoorbeeld zien hoe je de metrieken van Applicatie Performance Monitoring op Splunk ITSI aansluit met daarbij een integratie naar ServiceNow. 

High Level Design  - APM integratie Splunk ITSI & ServiceNow

Applicatie Performance Monitoring integratie naar Splunk

Als uitgangspunt nemen wij een bestaande databron, de APM-monitoring in een organisatie, links in het HLD als cloud oplossing weergegeven. Dat is de monitoring die door middel van metingen inzicht biedt in de beschikbaarheid- en performance van een applicatie, dienst of een omgeving. Uit de APM-monitoring komen inzichten. Dit zijn de ruwe meetresultaten maar ook al verrijkte data zoals beschikbaarheid- of performance alerts. 

Laten we kort stilstaan bij het versturen van de data naar Splunk. Veelal wordt hiervoor gebruik gemaakt van een webhook. Splunk biedt hiervoor zelf de HTTP Event Collector (HEC) aan. Middels HEC wordt de data op een veilige manier naar de Splunk omgeving verstuurd waarnaar het direct in de juiste index wordt opgeslagen. In het HLD noemen wij deze index de APM_Name_Private_index. 

Met de alert-data in Splunk is de vervolgstap deze gereed te maken voor Splunk ITSI. Hiervoor is het nodig om de structuur van de data aan te passen naar een structuur die geschikt is voor ITSI. Dit aanpassen van de data naar een geschikt formaat wordt normaliseren genoemd en licht ik graag even toe.

Normaliseren is nodig zodat Splunk ITSI begrijpt wat voor data het binnen krijgt en wat het vervolgens met een event moet doen. Normaliseren lijkt in het begin wat omslachtig, de data zit immers al in Splunk. Het is daarom waarschijnlijk al eerder genormaliseerd tijdens het indexeren, dus waarom moet je het nog een keer aanpassen?

Zie het als volgt; wanneer je meerdere databronnen aansluit op Splunk, dan is de data los van elkaar goed te begrijpen en ook toepasbaar voor ieders doeleinde. Het is echter moeilijk om de data voor hetzelfde doeleinde te gebruiken. Wanneer de data genormaliseerd wordt naar een eenduidig bestandsformaat met daarbij een eenduidige key-value indeling is het voor Splunk ITSI mogelijk wat met de events te kunnen doen. 

Belangrijk hierbij is dus dat de key-value indeling door normalisatie hetzelfde wordt. Als voorbeeld: waar in de APM Name Private index links in de afbeelding weergegeven, een veld als responstijd wordt aangeduid met de key-value combinatie performance=value, zal in index 2 dat veld bijvoorbeeld timer=value zijn en in index 3 responsetime=value. Door normalisatie kan dat voor alle drie de databronnen eenduidig aangepast worden naar itsi_duration=value. 

Voor het normaliseren van data naar ITSI-events zijn regels en richtlijnen opgesteld, welke door Splunk zijn opgenomen in het Common Interface Model (CIM). Hierin staat beschreven welk veld(key) welk doeleinde(value) heeft en worden er voorbeelden gegeven voor hoe deze toegepast kunnen worden. Los van het CIM zijn er ook Cheat Sheets en Templates beschikbaar gesteld voor veel gebruikte integraties.

Data Normalisatie middels een scheduled search

Het normaliseren – oftewel het hernoemen van velden – gaat in de praktijk middels een Scheduled Search. Zoals de naam al zegt is een Scheduled Search een zoekopdracht in Splunk die je herhaald kan laten uitvoeren. Voor dit doeleinde kijkt de zoekopdracht iedere minuut of er in de APM_Name_Private_index nieuwe events binnen zijn gekomen. Indien dit het geval is worden de velden uit de events middels meerdere eval commando’s aangepast naar ITSI-velden en middels een collect commando weggeschreven naar een aparte summary index, in het HLD genaamd apmname_alerts_itsi_public. 

Onderstaand een stuk voorbeeld code SPL waarbij de eval commando’s voor de belangrijkste ITSI-velden worden toegelicht. In de praktijk dient deze code aangepast te worden op de eigen situatie. 

```Voorbeeld event*```
Service=Main_Web_App
Type=Availability
DataSource=Login_App
EventId=123456789_1234567890
Business_Service=IOL_GROUP

```Voorbeeld Eval Commando’s```
| eval itsi_entity=Service. "-". Type. "-".DataSource
| eval itsi_correlation_key=itsi_entity
| eval itsi_urgency=Medium, itsi_impact=Low
| eval itsi_event_key=if(isnull(existing_itsi_event_key) OR existing_itsi_event_key=="", itsi_entity. "~".EventId, existing_itsi_event_key)
| eval  itsi_tag=mvappend("ITSI", "SNOW")
| eval itsi_business_service=business_service

Itsi_entity
Een entity kan gezien worden als de titel van de melding. 


itsi_correlation_key
De correlation_key - in dit geval gelijk aan de entity - zal events in ITSI groeperen en zal vervolgens proberen te kijken of er correlaties mogelijk zijn binnen de entitiy en tussen de entities. Tip: maak een entiteit en dus een correlation_key niet te algemeen, maar ook niet te specifiek. Bij te algemeen krijg je te veel events in 1 entiteit en bij te specifiek, heb je weer te veel entiteiten en dus te weinig events per entiteit. Een belangrijke afweging hierin is dat je wat moet kunnen met de informatie van meerdere events in 1 groep. Voor APM is in dit geval de entiteit dus Service-TypeAlert-Stapnaam, bijvoorbeeld bedrijfsapplicatie-beschikbaarheid-inloggen.


Itsi_urgency en itsi_impact
Hiermee wordt de urgentie alsmede de impact aangegeven voor het event. Een melding wordt afgesloten (positieve alert) door beide als status low mee te geven.


itsi_event_key 
Om nieuwe events aan te maken, maar ook om op een bestaand event door te schrijven wordt gebruik gemaakt van een event_key. Ieder nieuw event heeft een unieke eventID. Tijdens de normalisatie wordt middels een correlatie zoekopdracht gekeken of er nog een openstaand probleem is. Bijvoorbeeld een performance melding met als impact Warning. Als bij een nieuw event de impact/urgentie wijzigt, bijvoorbeeld naar een Critical status, wordt op dat event doorgeschreven. In dat geval wordt dan de existing_itsi_event_key gebruikt.


itsi_tag
eval  itsi_tag=mvappend("ITSI", "SLACK","SNOW") 
Middels een tag wordt aangegeven welke integratie opgepakt moet worden. In dit voorbeeld wordt het event opgenomen door ITSI en wordt ook de integratie Service Now Now-IT gestart. Er zijn echter meerdere standaard integraties mogelijk, zoals naar Slack of Teams, maar ook een custom integratie zoals naar TopDesk.


Itsi_business_service
| eval itsi_business_service=business_service
Een business service komt in dit geval overeen met de business service in Service Now en zal er dus voor zorgen dat dit evenement op juiste manier gekoppeld wordt aan SNOW. Tijdens het normaliseren is het dus mogelijk om custom velden als deze toe te voegen.

Overige velden kunnen nog zijn: itsi_instruction, itsi_summary, itsi_message.  Dit zijn velden met aanvullende informatie, een oplos instructie, samenvatting, en uitgebreidere uitleg van de melding kunnen hier worden opgegeven.

Tijdens de normalisatie is het event middels het collect commando verstuurd naar de apmname_alerts_itsi_public summary index. Vanuit deze public index wordt door een correlation search de events opgenomen door Splunk ITSI. Dit is een standaard functionaliteit binnen Splunk ITSI en kan gezien worden als een macro die een index scant op nieuwe events en de integratie naar Splunk ITSI start. Eenmaal in Splunk ITSI komen de events binnen als “notable event”. Een notable event kan gezien worden als een losstaand alert. Wanneer een alert weer een positieve status heeft, bijvoorbeeld inloggen applicatie was onbeschikbaar en nu weer beschikbaar, wordt het event afgesloten en toegevoegd als Episode. Op zowel de losstaande notable events als de episodes worden correlatie zoekopdrachten gedaan en kunnen incidenten gestart worden. Deze correlaties binnen een databron als tussen databronnen toont de kracht van ITSI.

Voorbeeld: uit een notable event wordt een incident aangemaakt, bijvoorbeeld applicatie 1 is traag bij opstarten (performance), of inloggen werkt niet (beschikbaarheid). Uit episodes kunnen middels deep-dives alerts komen als, de afgelopen 4 maandag ochtenden was het inloggen traag tussen 08:00 en 10:00 of inloggen werkt iedere dinsdag tussen 07:00-08:00 niet. Ook kunnen correlaties gelegd worden tussen databronnen, een incident als, deze servers hadden een hoog CPU, gelijktijdig was de applicatie traag.

Het incident wordt dus aangemaakt binnen ITSI. Een overzicht van de openstaande en/of gesloten events is terug te vinden in de Episode Review:

Voor de integratie naar ServiceNow wordt een standaardoplossing binnen ITSI aangeboden, zie hiervoor de Splunk Docs - ITSI SNOW. In ons voorbeeld is in 1 van de besproken velden, de itsi_tag aangegeven om de integratie naar ServiceNow te starten. Vanuit Splunk ITSI wordt middels een XML/SOAP call een incident in ServiceNow aangemaakt en/of voorzien van een nieuwe status. De integratie tussen Splunk en ServiceNow werkt bidirectioneel. Indien in ServiceNow dus een update wordt doorgevoerd, wordt deze ook naar Splunk verzonden en vice versa.

Event in ServiceNow – aangemaakt door Splunk ITSI

In dit artikel heb ik jullie een inkijkje gegeven over het aansluiten van data op Splunk ITSI. Wij hebben gebruikmakend van HEC, alert data van een APM-product gestuurd naar een Splunk omgeving. Middels een saved search hebben wij vervolgens de event data genormaliseerd naar een Splunk ITSI event. Tijdens het normaliseren is middels eval commando’s aangegeven wat voor event (entiteit) het betreft en wat de status (urgentie/impact) is. Ook is aangegeven onder welke groep (correlation_key) het nieuwe notable event valt en of het gaat om een nieuwe gebeurtenis (event_key) of een vervolg (existing_event_key) op een bestaande gebeurtenis betreft. Doordat in de Tag is aangegeven, ook de koppeling naar ServiceNow Now-IT te starten, zal vanuit ITSI ook direct het evenement hiernaartoe doorgestuurd worden en gekoppeld worden aan de business_service, met daarin mogelijk een instructie, samenvatting en aanvullend bericht.

Persoonlijk vind ik Splunk ITSI een gave oplossing, na al dan niet wat handmatig instellen in het begin, kan vervolgens veel waarde gehaald worden uit de automatische correlaties en berichtgeving die eruit volgt.

Splunk consultant Tom de Bruijn  legt in 5 stappen uit uit hoe je Applicatie Performance Monitoring kan aansluiten op Splunk IT Service Intelligence.

Applicatie Performance Monitoring aansluiten op Splunk IT Service Intelligence

In april 2021, Bouke Nijhuis has discussed 4 tips for passing the Java 11 Developer exam. In this blog I am going to expand on those original tips and add some more. 

The Java Developer exams are notorious for asking difficult and misleading questions. But why do so many people find them so hard? Do they just lack experience? Are the questions incredibly difficult? Don’t you have enough time to answer all the questions? The simple answer to all these questions is ‘No’. Not that it’s an easy exam, but with the right preparation you can pass it during your first try.

I have previously taken the various Java 7 and 8 OCA/OCP exams before starting to prepare for this exam. And let’s be honest the difference between Java 8 and 11 compared to the difference between Java 7 and 8 is minimal. Beside adding a few new methods here and there, and adding annotations to the scope of the exam. I can only say that the new feature of modules is the only significant change from 8 to 11. However, I scored lower during this exam than the Java 8 OCP I took 3 years ago. Have I become a worse developer over time? What’s wrong?

Well no. Practice makes perfect, but only the right practice. This introduces my first tip.

Ironically, the more experience you have as a developer after a point the test will become harder, not easier. Why? Simple, because the majority of the stuff tested during this exam you never really need to memorize by heart when working as a developer. 

For example, we all know auto type conversion in Java: an int can safely be converted to a float, and a float in turn can be safely converted to a double. But what about a short to a char. Or a char to an int? Or a boolean to a byte. The exam won’t directly ask you this. But when looking for compile errors there could be a few questions where answers differ only by type. When taking the exam, I found myself hesitating and wasting a lot of time on such simple things. 

It is also important to note that Oracle has decided to no longer split the exam into two parts: the OCA and the OCP. Now it is just a single larger exam. The OCA consisted of the more basic fundamentals and the OCP covered the ‘more difficult’ concepts of lambda's, extended libraries, modules, etc. So, I thought that it would maximize my chances of passing if I focused 95% of my time on the (formally) OCP chapters of the study book and just quickly scan the other ‘easier’ chapters. I was wrong. I would estimate that 60% - 70% of the questions were straight out of the Java 8 OCA exam. 

In short, it is easy to pass by having a good knowledge of the basics and an ok knowledge of the more advanced topics.

Tip 6 - Practice as many exam questions as possible

Remember you are not only studying to be a good Java developer; you are also studying to be a good test taker. In an ideal world, these would be the same thing. However, that is not the case. It is important that you learn how to read and answer the Oracle exam questions.

The only way to do this is by answering as many practice questions as possible. The questions provided by your study guide of choice, is a great place to start. However, I would also take advantage of the many other sources available. 

For example, the creators of the “OCP Complete Study Guide'' also offer a complementary book containing hundreds of pages of extra practice questions. You can also find online practice exam software which can be purchased and accessed via Udemy or other educational platforms. 

I cannot stress how much I learned while answering practice questions. Not only is this the best way of getting to grips with the material, but the best way to reduce the time you need to answer a question. Making you better and faster at answering the exam questions. 

So, the moment has come and you are sitting behind a computer ready to take the exam. You will need to answer 35 of the 50 questions correctly in 90 minutes to pass. Time is going to start flying. What can you do to maximize your time management?

Fortunately, you can easily flag questions and revisit them later after completing the final question. My tactic is to, first, quickly go through all the questions not spending more than 20/30 seconds on a single one. If the question appears large or it seems like you are going to need more time walking through multiple steps keeping track of the value of a variable, just flag it and move on. If you are hesitant between two answers, flag it and move on. If you read a question and you panic, flag it and move on.

Most likely, the majority of the questions will be relatively straightforward, you should know the answer in at least 30 seconds. At least by answering these questions first, you will have answered the questions you find easy, and after realizing that you are confident that you have answered 50-60% question hopefully correctly, you will be more confident and less stressed to be able to take the time needed to answer the questions you flagged on a second run.

During the second run continue following the first tactic, but now unflag the questions you feel confident are correct. You will be left with less flagged questions. Now just repeat until there are no questions left, or you run out of time. Most of the time I find myself with time to spare, or just staring at one or two questions at the end. No big problem.

A final tip, sometimes the clock runs down to zero and the exam automatically finishes before you have answered every question. Therefore, it is important before going to the next question to always give an answer. If you don’t know, just guess. Nothing ventured, nothing gained. If you flagged the question, you will have another chance and hopefully enough time to give a more confident answer.

A previous blog has discussed 4 tips for passing the Java 11 Developer exam. In this blog Ian van Nieuwkoop is going to expand on those original tips and add some more.

Four more tips to pass the Java SE 11 Developer exam

In de afgelopen jaren heb ik bij verschillende opdrachtgevers in diverse branches mogen werken, zo ook bijvoorbeeld voor de overheid. Vanuit een van deze opdrachtgevers was de wens om een nieuw platform te bouwen en beschikbaar te stellen aan meerdere doelgroepen en moest deze diverse functionaliteiten ondersteunen. De keuze stond vooraf al vast dat deze applicaties en API’s via een microservices architectuur ontwikkeld zouden gaan worden. 

Kort gezegd bestaat een landschap van microservices uit applicaties die ontwikkeld zijn als een verzameling van applicaties (dus functionaliteiten). Elke applicatie kan je zelfstandig ontwikkelen, implementeren en onderhouden zonder afhankelijkheden van andere applicaties.

Om een idee te geven hoe het platform is ontwikkeld doe ik in deze net alsof wij een pizzeria genaamd “De CINQeria” zijn met soortgelijke vraagstukken, namelijk:

De consument wil een lijst van pizza’s zien, samenstellen en bestellen via de website en een app;

De pizzeria wil de bestellingen ontvangen, bereiden en bezorgen via een webapplicatie en app. 

Een landschap van microservices uit applicaties (van frontends) die ontwikkeld zijn als een verzameling van applicaties (dus functionaliteiten).

Onze laatste blogs