DEV Community: Thomas P. Fuller

Tutorial: Learn how to use the H2 Database with Spring Boot! 🤔

Thomas P. Fuller — Tue, 25 Jun 2024 11:59:22 +0000

In this instructional we’ll review an example application which is written in the Groovy Programming Language and which demonstrates how to use the H2 relational database (H2 DB / H2) with Spring Boot.

The benefit from using the Groovy Programming Language, in this case, is that it allows an example to ship exactly one file which contains everything we need in order to run the application.

The H2 Database Engine is a powerful open-source relational database which is written in the Java Programming Language and which is used with some frequency in software development projects — especially when it comes to testing applications.

Using H2 with the Spring Framework and with Spring Boot, in particular, is a common use case, one which we’ll demonstrate here.

In the next section we’ll take a look at the example and dissect, in detail, what happens in each step.

Note that in a few places I’ve added code which should not be required if we were to write this same solution using the Java Programming Language and a properly structured Maven project — I attempt to point this out, where appropriate.

H2 with Spring Boot Example on GitHub

Included here is a link to the GitHub gist pertaining to the example used to demonstrate connecting the H2 Relational Database with Spring Boot -- you should be able to paste this script into the groovyConsole and run as-is.

Spring Boot With H2 DB Example Maven Dependencies

The following dependencies are used in this example:

The Groovy Grape dependency management system should find these dependencies automatically when the script is executed however for reference purposes I’ve included these here.

An example pertaining to using the H2 Database Engine with Spring Boot

In this section we’ll take a look at the script in closer detail and go over what’s happening in each step.

Preconditions
In order to run this example, you will need the following:

Java version 22.0.1 (required)
Groovy 4.0.17 (required)
groovyConsole (optional)

This script can be executed using Groovy alone hence the groovyConsole is optional.

The script uses the Groovy Adaptable Packaging Engine (Groovy Grape) to pull in dependencies from Maven Central hence a connection to the Internet is required as well.

I’ve included an example of what the output should look like when running this script from the command line here.

The red arrow points to the command used to run the script, and orange arrow points to the log statement that indicates the script is starting, and the blue arrow points to the log statement that indicates that the script has finished running.

In this example, the script runs a Spring Boot application that creates a table in the H2 DB, executes several CRUD (create, read, update, delete) operations on that table, and then drops the table.

The Groovy script runs to completion successfully and then exits.

Step One: Declare a package.

When we define the Spring Boot Application, we’ll include the scanBasePackages setting, which requires a package name so we set that here.

Step Two: Add the Groovy Grape GrabConfig annotation.

In step two we need to add the Groovy Grape GrabConfig annotation and also set the systemClassLoader property to true — if we do not have this an exception will be thrown when the script is executed.

Step Three: Grab dependencies and import required classes.

In step three we need to grab the dependencies necessary to run this example as well as import required classes — this includes the Spring Boot, H2 Database, and other supporting classes.

Note that we’re using the Hikari database driver in this example.

See the Maven Dependencies section in this article for complete details.

Step Four: Obtain a reference to an SLF4J logger.

We’re using the SLF4J log delegation framework in this example and we’ll send messages to console output so we can watch what’s happening as the script executes.

The HikariCP dependency is one other framework that we’re using that also uses SLF4J and we’ve included this high performance connection pooling implementation in this example.

Step Five: Configure H2 database datasource and JdbcTemplate beans.

In the fifth step we’ll configure the H2 Database datasource which utilizes the HikariCP high performance connection pool dependency as the datasource type.

Since this example demonstrates some simple CRUD operations executed against the H2 Database from a Spring Boot application, we’ll also configure an instance of JdbcTemplate here which uses this data source.

Note that we’re assigning the HikariDataSource class as the datasource type.

The H2 DB instance configured in this example will reside in-memory only — if we want to persist this information to disk then we need to change the URL.

Step Six: Create a repository class.

In this step we implement a repository that contains the CRUD operations that we can execute on the H2 Database instance via the JdbcTemplate, which is autowired in this example by Spring Boot.

Step Seven: Implement a service bean.

In this step we implement a transactional service bean which has stop and start lifecycle methods along with convenience methods that delegate to the repository bean.

The start method creates the example table in H2 when Spring Boot initializes the beans that the container is managing, and the stop method drops the example table before the container stops.

Other methods defined in the ExampleService deliver convenience and hide implementation details.

Using a service aids in reuse and is also helpful when testing our code.

As the image has been truncated, refer to the full example below or on the GitHub Gist for the complete implementation details.

Step Eight: Implement the Spring Boot CommandLineRunner interface.

In this step we implement the Spring Boot CommandLineRunner specification.

Our implementation includes executing CRUD operations via the service created in step seven against the H2 Database.

We log some information along the way so we can see what happens as each CRUD operation completes.

Step Nine: Configure Spring Boot Application for Component Scanning

The code in the snippet defines a Spring Boot application and specifies the base package for component scanning.

Step Ten: Configure and then run the Spring Boot application.

The code in this snippet configures and then runs the Spring Boot application with the following configuration:

Initialize SpringApplicationBuilder: Creates a builder for the Spring Boot application using H2SpringBootExampleApplication.
Set Profiles and Web Application Type: Configures the application to use the default profile and disables the web environment (this is not a web application so we don’t need this).
Set Parent Context: Specifies the BeanConfiguration, ExampleRepository, ExampleService, and ExampleCommandLineRunner classes as components in the parent context.
Run the Application: Execute the application with the provided arguments.
Close the Context: Closes the application context — this step ensures that the stop lifecycle method in the service (see step six) is called before the Spring Boot example application has exited resulting in the names table in the H2 DB being dropped.

Finally, the script logs a completion message and then exits.

The next section includes the complete Spring Boot with H2 Database example script.

Spring Boot With The H2 Database Engine Complete Example

Please refer to the original article or the GitHub gist for the complete example.

Tutorial Conclusion

I hope that this instructional has provided adequate guidance as well as a useful software engineering solution regarding how to use the H2 Database with Spring Boot.

I have another guide that details how to receive database event notifications from the H2 Database using triggers which may be of interest as well.

How To Write Awesome Article Titles For SEO 💎

Thomas P. Fuller — Mon, 16 Oct 2023 16:11:53 +0000

If you’re wondering how to write awesome article titles for SEO then this tutorial should help to address this question.

I use the same strategy for other articles that appear on this website and for posts I’ve published elsewhere.

My goal is to not just write something that a human would appreciate but also to conduct some basic research in an effort to find a long-tail keyword (LTK) that will also appeal to search engines, the Google Search Engine being my primary concern, and to include that target keyword combination in the title.

I use various ChatGPT prompts when engineering the post title and we’ll cover this too.

This article started as an update on LinkedIn where I put together a few ideas regarding how we can engineer the best SEO titles for the purposes of appealing to both the human reader as well as to search engines.

There are seven steps we need to follow and the first involves doing a bit of research about article titles.

There's extra information included in the original article.

Step One: Review Several Articles On The Best SEO Headlines

Below I’ve included several articles that can help develop a better understanding of strategies and tactics you can use to develop an awesome blog post title.

Quoting from the article entitled 13 Types of Blog Headlines That’ll Get You More Traffic [+ Examples]:

You might not realize it, but your headline could be the reason you’re losing traffic. In fact, on average, only 20% of those who read your headline will click through to read your article. That means good headlines lose 80% of your audience.

Great headlines, though, can make a dramatic impact in the opposite direction. You can increase the traffic to your articles by as much as 500%, based solely on the headline.

Below I’ve included several of the best SEO headlines by type:

How-to titles

"How to Make the Perfect Cup of Coffee"

How-to titles are actually quite important and can be helpful as backlink magnets.

List-based titles (list posts / listicles)

"10 Reasons Why Yoga is Good for Your Health"

List-based articles, also known as list posts or listicles, can perform very well because they’re generally easy to scan and read.

List posts are also easy to post on social media platforms so when reusing content, the title in this case can have an importance that extends well beyond the article.

Question-based titles

"What are the Benefits of Meditation?"

According to the article entitled Google Search Statistics (dated 2020):

…14.6% of all Google searches come in the form of a question.

so when developing a question-based title, it will likely benefit the writer to use the exact question people are searching for as their article title.

Opinion-based titles

"Why I Think Veganism is the Future of Food"

Benefit-driven titles

"The Benefits of Going for a Morning Run"

Power words

"Discover the Secrets to a Better Life"

Time-sensitive titles

"Why Now is the Time to Start Investing in Real Estate"

Controversial titles

"Why I Disagree with Popular Parenting Techniques"

Personal experience titles

"My Journey to Becoming a Better Writer"

Numbers-based titles

"5 Simple Ways to Improve Your Productivity."

See also the Backlinko link bait article and any other articles on this specific subject. I’ve included some tweets to threads about this subject in the original article.

The article entitled How To Write Great SEO Titles suggests that we should prefer to use title or sentence case and that, while this doesn’t matter to SEO, per se, how we choose to capitalize can impact the reader (See the sections entitled "Capitalize Properly" and "Does Capitalization Affect SEO Rankings?").

Step Two: Determine The Search Intent

Search intent, or user intent / audience intent, refers to the reason behind a user’s search query.

When it comes to Search Engine Optimization (SEO), understanding search intent is important because it helps to optimize content in order to meet the user’s needs and provide relevant search results.

There are four main types of search intent: informational, navigational, transactional, and commercial investigation.

We’ll briefly cover each of these below — for more information see the Yoast article entitled “What is search intent and why is it important for SEO?“.

Informational Search Intent: People looking for specific information.
Navigational Search Intent: People looking to visit a specific website.
Transactional Search Intent: People looking to buy something now.
Commercial Search Intent: People looking to buy something in the future.

When it comes to optimizing content, this includes the title too.

In step three we’ll perform some basic target keyword research and knowing what the search intent is should help to narrow down an appropriate long-tail keyword with a search intent that matches what the user is looking for.

Step Three: Locate a Long-Tail Keyword for SEO Purposes

For step three I’ll use the SEMrush Keyword Magic Tool to find a long-tail keyword (LTK) combination.

Ideally, the long tail keyword should be both high volume and low competition — if we end up ranking for this target keyword combination we may end up getting a decent amount of traffic to the post — especially if we end up in the top three positions in the search engine results page (SERP).

If you have a long-tail keyword already in mind, then make sure this is included in the headline.

Designing a compelling headline which incorporates a long-tail keyword may require some creativity especially if the target keyword requires many characters.

What is a Common Benefit to Long-Tail Keywords?

Targeting long-tail keywords is an important search engine optimization (SEO) strategy and involves finding target keyword combinations that are focused, less competitive, and which should help to drive traffic to a website.

The following quote is from the Search Engine Land article entitled Back to basics: What does 'long-tail' keyword really mean?:

If a particular niche has a total search volume of 100,000 and is accompanied by 1,000 keyword opportunities, then by this logic, an estimated 20 to 30 percent of them will be short-tail keywords, while long-tail keywords will account for the remaining 70 to 80 percent.

and the quote below is from the AIOSEO article entitled How to Find Long Tail Keywords and Increase Organic Traffic drives this point home:

...long tail keywords make up for 70% of search traffic. So if you want to get more organic traffic and improve your SEO rankings, you should definitely use long tail keywords in your content.

Why you should also target zero search volume keywords

It’s important to keep in mind that tools like the SEMrush Keyword Magic Tool are often estimating search volume and, from time to time, we may find a target keyword that looks attractive and yet have zero search volume.

Below I've quoted this tweet by @NicheCampus about zero-volume keywords:

Some of my BEST and BIGGEST volume keywords came from digging around for “zero competitive keywords” which had “zero search volume” (from tools etc)

Not only are these free and easy to win Google’s #1 spot, they often have much more traffic than people expect.

I can speak with experience regarding this suggestion as I’ve used zero search volume keywords for various posts and was pleasantly surprised when the actual search volume was higher than I anticipated.

Step Four: Use ChatGPT To Research and Write the Title

In step four, we use a ChatGPT prompt to help us write the title.

ChatGPT can be incredibly useful for research purposes and that includes developing a title for a blog post.

In this example, we ask ChatGPT to create a blog post title that is no longer than 55 characters and also uses the long-tail keyword we discovered in the previous step.

We can ask ChatGPT to give us several variations and in a few seconds we can review many choices and either use one, take ideas from the results, or use one and improve it such that it works with our post.

Using ChatGPT in this manner can be a significant time-saver and is a strategy that I’m using with some frequency.

and

Note that if we can generate one blog post title, we can just as easily generate ten, 50, or 100.

The result can be useful in that we can use the blog post title exactly as generated if it’s appropriate, or we can take something which is close to what we need and improve it.

Step Five: Use The MonsterInsights Headline Analyzer Tool To Develop An Award-Winning Headline

Step five requires that we use a tool such as the MonsterInsights Headline Analyzer (MIHA) to engineer a solid headline that incorporates the long-tail keyword combination found previously.

ChatGPT may also give us a great title that requires no adjustment however if the score is not satisfactory we may want to rewrite the title in an effort to improve the score.

What is The MonsterInsights Headline Analyzer?

The MonsterInsights Headline Analyzer tool is a web application designed to assist users craft compelling and engaging headlines for their content.

By analyzing the quality and effectiveness of headlines, the MonsterInsights Headline Analyzer provides insights that can improve the overall impact of articles, blog posts, or marketing materials.

The MonsterInsights Headline Analyzer tool evaluates factors such as word choice, length, emotional appeal, and headline type to gauge the headline’s potential effectiveness.

MonsterInsights Headline Analyzer users can write SEO headlines that are both optimized for search performance and captivate readers, increase click-through rates, and ultimately enhance their content visibility.

The MonsterInsights Headline Analyzer suggests that you should strive for a score of 70% and above — we can set this bar higher and aim for 75% as the minimum score.

It may not be easy or even possible to achieve all of this given the parameters I’ve outlined and we may need to sacrifice something to make it work — in this case, I’m thinking the first to go will be the MonsterInsights Headline Analyzer score goal of 75% or better.

In this SEO headline example, we have text which is 46 characters long and the Monster Insights Headline Analyzer score is 90%, which is very good.

What Is The Best Length Of A Title In SEO?

We should endeavor to keep the length of the headline to no more than 60 characters however note that a character count of 55 appears to be the ideal length according to the article entitled The Ideal Length of Everything Online, Backed by Research.

Do we benefit from placing the long-tail keyword at the beginning of the blog post title?

ChatGPT suggests that the answer to this question is "no"; other supporting evidence is unavailable at the moment, and even if it did matter, it would be only one of many ranking factors and likely a negligible one at that.

Step Six: Add a Relevant Emoji To The Title ⛳️

In this step we can, if we choose to, and assuming we have enough space to do so, add an emoji to the title.

We need to be careful with this one and just because we can add an emoji to the title it doesn’t mean we should.

Also, note that where we place an emoji may be important too — we’ll get to this in a moment.

This exact subject has been studied already and below is a quote from the findings in the SEMrush article entitled "SEO Split-Testing Case Study: Should You Add an Emoji to the Title on Recipe Pages?" (August 2021) and to be clear, the variant group, in this case, is the title that contains the emoji:

The lines start to diverge right away in the first week. This means that the traffic to the variant group is performing better than predicted and shows that the test is a success. Ultimately, based on organic sessions, we see an increase in organic traffic of no less than 11.3%.

Where we place the emoji may be important as well.

In posts and pages on this site where emojis are included in the title these usually appear at the end of the text.

Google can rewrite titles and according to the SearchPilot article entitled “Can emojis in title tags be beneficial for SEO?” (April 2022):

Google was choosing not to include the emoji, and everything before it, leaving us with a shorter title than before the test, while also removing the primary keyword for the page from what was displayed in search results.

— and this is not good, of course.

This site has several pages which utilize emojis in the title however they appear at the end of the text and in several cases Google has decided to remove the emoji however the remainder of the title appears as it’s been written and without any negative consequences.

So my advice, given what’s been experienced above, is simply to make sure that an article title that contains an emoji is appearing correctly in search results once Google has indexed the page — if it does not appear correctly then you may need to move or remove the emoji and resubmit the URL for indexing in the Google Search Console.

I personally do not like this approach as we end up being forced to wait for the update to happen and, in my experience, that could take several weeks for the change to appear.

When developing the best SEO headlines, the emojis we have available are specified as a unicode standard and tools such as the All In One SEO Pack for WordPress include these emojis as one of the many product features.

Step Seven: Check that the title doesn’t already exist

If the exact title developed is already in use by another website, we should consider rewording the title as we don’t want to fall into direct competition with a page which has been ranked using verbatim the text we’ve developed.

Use ChatGPT To Generate Variations Of Your Best SEO Headlines With Emojis

If we’re not sure which emojis are appropriate for the title, we can use ChatGPT to quickly generate a few variations and then we can pick one.

In this example I use the ChatGPT prompt:

Provide me with ten example titles with appropriate emojis added to the end for the WordPress post entitled “Does your blog post have one of the Top 100 Best Headlines” and do not change the post title.

and we can examine the results in the image below.

Note that there’s likely a more concise way to word this ChatGPT prompt however in this case I needed to demonstrate how this works and intend to revisit this in time.

We could also prompt ChatGPT to create title variations (see step #4) with the emoji included and possibly kill two birds with one stone.

Emojis In The Title Do Not Help Or Hurt SEO

According to the Search Engine Journal article entitled "Google Says Emojis Won’t Hurt Or Help SEO" the presence of an emoji won’t hurt or help SEO.

But, as we’ve already discussed, there can be a positive return regardless and the presence of one or more emojis in the title can have the potential to improve traffic from search engines as well as social media platforms because people may still see the graphic.

Article Conclusion

This article was initially published on my blog on the 10th of November 2022 and has since then undergone many revisions including new content and adjustments for clarity as well as for SEO.

Tutorial: Learn How To Mount A Local Directory Into A Pod In minikube

Thomas P. Fuller — Thu, 10 Dec 2020 03:36:55 +0000

The use case for this guide is as follows: A software developer needs to mount a local directory into a pod in minikube since pod storage is ephemeral and will be deleted when the pod is deleted.
In the following article, we're using Minikube (v1.14.2) with Kubectl (1.19) running on Ubuntu 20.04.1 LTS.

If we want the storage to survive a pod deletion or to be shared between pods, then we can mount a directory from the local file system — this could be a requirement, for example, when you have a database running in the pod but the storage is located on the local filesystem.

In this article, we’ll cover several examples that demonstrate how to mount a local directory in a pod running in minikube.

We rely on minikube (v1.15.1) with kubectl (1.19.4) on Ubuntu (20.04.1 LTS) as well as on Mac OSX (10.13.6 High Sierra).

The k command, which appears below, is defined as follows:

alias k='kubectl'

In the next section we’ll take a look at several use cases regarding why a software developer would want to mount a local directory in a pod in Kubernetes and/or minikube and following that we’ll take a look at a few solutions.

Use Cases for mounting a local directory in a pod in Kubernetes

When setting up a local Kubernetes cluster using minikube, you can utilize hostPath volumes to mount specific files or directories from the host machine into your pods, and define volumeMounts with mountPath in your pod specification to efficiently manage file and directory access within your containers.

For detailed management and troubleshooting of these volumes, use ‘minikube ssh‘ to access the cluster’s command line.

Mounting a local directory into a pod in Kubernetes can be useful for several reasons and I’ve included five use cases below.

At a high level, these benefits include data sharing and accelerating the development and testing of software.

Configuration Injection

You can mount a local directory containing configuration files or environment variables into a pod.

This allows you to dynamically adjust the behavior of your application without modifying the container image.

As you update the configuration on the host machine, the changes are immediately reflected in the pod thereby facilitating easy configuration management.

Data Sharing and Backup

Mounting a shared local directory allows you to share data between containers within the same pod.

Mounting a shared local directory enables seamless communication and data exchange, such as sharing log files or database backups between containers.

Additionally, you can use local directories as temporary storage for data backups and then mount the local directories into pods for further processing.

Persistent Data Storage

You can mount a local directory into a pod when one or more applications require persistent storage.

This approach can be particularly useful during development and testing, and allows you to use your local machine’s file system as a data storage solution.

Local storage is not recommended for production scenarios due to its limitations and lack of scalability however it is perfectly suitable for development and testing purposes.

Debugging and Troubleshooting

When debugging an application within a pod, mounting a local directory with debugging tools, scripts, or diagnostic utilities can help you quickly investigate issues.

Mounting a local directory allows the developer access to debugging tools and logs directly from the local machine and streamlines the troubleshooting process.

Development and Testing

Mounting a local directory can accelerate the iteration process when it comes to developing and testing software.

Instead of building and pushing container images for every code change, you can mount the directory containing the source code into the pod and enable real-time testing and observation of the changes as development progresses.

Keep in mind that while mounting a local directory can be helpful for specific use cases, it’s essential to consider the security and portability implications as it pertains to production software.

Using ConfigMaps, Configuration Secrets, or network-attached storage solutions such as Persistent Volumes (see also Configure a Pod to Use a PersistentVolume for Storage) and Persistent Volume Claims (PVCs)) might be more appropriate for production environments, where data needs to be managed securely and scaled effectively.

In the next section we’ll take a look at what the minikube mount command does and then we’ll take a look at three solutions that we can use to mount a host directory in a pod in minikube.

What is minikube mount?

The minikube mount command allows the developer to mount a local directory on the host machine into a running Minikube cluster, thereby making it accessible to containers running in the cluster.

In the following examples we do not use the minikube mount command directly — instead we apply a configuration yaml file which has the mount specification details included.

See also the page on mounting filesystems regarding how to mount a host directory into the virtual machine (VM) on k8s.io for more details regarding how minikube mount is used.

Solution #1: Mount a subdirectory within user's home into a pod in minikube)

In the first solution, which is also the easiest solution in this article, we mount a subdirectory within the user’s home directory into a pod in minikube.

This solution was inspired by #1 (Akshay Sood, specifically) and facilitates the same result as Solution #2 however without the requirement to pass the –mount and –mount-string args.

The pod configuration file looks very close to the one used in Solution #2 as well — direct your attention to lines 14 (volumeMounts) and 17 (volumes).

This works because minikube mounts the /Users directory by default on Mac OSX, which is what we’re using for this specific solution.

Refer to the homedir package documentation as well as the for more information regarding the directory paths per specific supported operating systems (Apple OSX, Linux, and Microsoft Windows) [12 & 13].

I also have a simple script, which is written in Go, in GitHub, which displays the value of the user’s home directory.

In the image below we can see which directory has been mounted in minikube by invoking the df command with the h option, for displaying human-readable output, and the l option, which reveals information about locally-mounted filesystems.

Step One: Modify the hostPath in the pod configuration below to point to the user home directory.

Here’s the pod configuration:

In this example, we start minikube absent any of the mount-related args.

When the pod is created the /etc/minimounted/ directory will exist and it will be correctly mapped to the local directory.

We can see the output of this example in the following image (todo: double-check this image as it may not be the correct one to use here):

Step Two: Start minikube

The second step requires us to start minikube using the hyperv-virtual-switch option as follows:

minikube start --hyperv-virtual-switch "My Virtual Switch" --v=4

In this example the –hyperv-virtual-switch parameter is described on k8s.io as:

Name of the virtual switch the minikube VM should use. Defaults to first found

and we’re using “My Virtual Switch” as the name. The –v option sets the log level verbosity.

Step Three: Apply the configuration.

In the script below we apply the configuration file.

kubectl apply -f ./nginx-hp-minimounted.yaml

We can see the output when the kubectl apply command is executed below.

Step Four (optional): Test that the path is available in the pod in minikube

We can test that the path is available by getting command line access to the pod in the myns namespace and checking that the path exists as follows:

kubectl exec nginx-minimounted -n myns -it -- /bin/sh ls -la /etc/minimounted

Below I’ve included the complete script for running and testing this solution.

minikube start --hyperv-virtual-switch "My Virtual Switch" --v=4 kubectl apply -f ./nginx-hp-minimounted.yaml kubectl exec nginx-minimounted -n myns -it -- /bin/sh ls -la /etc/minimounted exit

If everything worked as we expect it to we should see something that looks like what appears below.

And that’s it for this example.

Solution #2: Mount a directory outside of user home into a pod in minikube

Refer to solution #2 in the original article for the complete example.

Solution #3: Mount a directory other than user home, without restart, into a pod in minikube

Refer to solution #3 in the original article for the complete example.

Tutorial Conclusion

If you liked this instructional then you may also like the following articles:

See the Kubernetes category and the containerization category for other articles that may be of interest.

Questions and comments are welcomed.

Answers to Five Kubernetes CKAD Practice Questions (2021)

Thomas P. Fuller — Tue, 17 Nov 2020 21:13:45 +0000

While doing some work with Kubernetes (K8s) and studying for the CKAD exam, I came across a page on Matthew Palmer's website entitled "Practice Exam for Certified Kubernetes Application Developer (CKAD) Certification" and which contains five practice questions, which I'll go over here. If you see a problem with anything I've done below, including inefficient solutions, please let me know in the comments.

We will focus on not just showing a possible solution to each problem but also verifying our work.

Since we're limited to the kubernetes.io website when taking this test, this site is referenced where appropriate -- in particular the kubectl cheat sheet page is not a bad place to start and we can search for what we need here as well.

Lastly, with each of these questions, we need to pay particular attention to the namespace requirement.

This article relies on minikube running on Ubuntu along with the Oh My Zsh shell.

The k command is defined as follows:

alias k='kubectl'

Let's take a look at the first question.

Question #1

The first question from [1] is as follows:

"Create a namespace called ggckad-s0 in your cluster.

Run the following pods in this namespace.

1. A pod called pod-a with a single container running the kubegoldenguide/simple-http-server image

2. A pod called pod-b that has one container running the kubegoldenguide/alpine-spin:1.0.0 image, and one container running nginx:1.7.9

Write down the output of kubectl get pods for the ggckad-s0 namespace."

We can hack together a pod by hand or we can autogenerate it, which should be the preferred option as we don't want to waste time with this if we can avoid it. The following commands can be used to autogenerate each yaml file: one for the kubegoldenguide/simple-http-server container, one for the kubegoldenguide/alpine-spin:1.0.0 container, and one for the nginx:1.7.9 container.

kubectl run nginx --image=kubegoldenguide/simple-http-server --dry-run=client -o yaml > simple-http-server.yaml

kubectl run nginx --image=kubegoldenguide/alpine-spin:1.0.0 --dry-run=client -o yaml > alpine-spin.yaml

kubectl run nginx --image=nginx:1.7.9 --dry-run=client -o yaml > nginx.yaml

We can use these files to create the pod-a and pod-b yaml files, which are required for this question.

The configuration file for pod-a appears as follows:

And the configuration file for pod-b appears below:

We need to first create the namespace as per the instructions:

k create namespace ggckad-s0

Next, we can apply this configuration:

kubectl apply -f pod-[a or b].yaml --namespace ggckad-s0

The final instruction for this question indicates that we need to "[w]rite down the output of kubectl get pods for the ggckad-s0 namespace." -- this is accomplished as follows:

k get pods --namespace ggckad-s0

which yields the following:

Verifying Our Solution

Below we have the entire script that we use in this example. We check the logs for all containers in order to see that they're running correctly.

k create namespace ggckad-s0
k apply -f pod-a.yaml --namespace ggckad-s0
k logs pod-a --namespace ggckad-s0
k apply -f pod-b.yaml --namespace ggckad-s0
k logs pod-b alpine-spin-container --namespace ggckad-s0
k logs pod-b nginx-container --namespace ggckad-s0

Running this script should yield the following output:

We can use the get events command to see the events that were collected.

k get events --namespace ggckad-s0

Running this command should yield the following output:

Notice that the nginx-container has started however there are no messages in the log that indicate that it's actually running so we'll check this by mapping port 19999 on the local machine to port 80 in the pod-b pod, which should point to the nginx-container which has the Nginx web server running on port 80.

kubectl port-forward pods/pod-b 19999:80 --namespace ggckad-s0

When we execute the line above, the output should look like what we have below:

Finally, we can now test that Nginx is running by browsing localhost:19999.

And that's it for this question.

Question #2

The second question from [1] is as follows:

"All operations in this question should be performed in the ggckad-s2 namespace.

Create a ConfigMap called app-config that contains the following two entries:

'connection_string' set to 'localhost:4096'
'external_url' set to 'google.com'

Run a pod called question-two-pod with a single container running the kubegoldenguide/alpine-spin:1.0.0 image, and expose these configuration settings as environment variables inside the container."

We need to first create the namespace as per the instructions:

k create namespace ggckad-s2

We need a ConfigMap, which can be created via the CLI as follows:

kubectl create configmap app-config --from-literal connection_string=localhost:4096 --from-literal external_url=google.com --dry-run -oyaml --namespace ggckad-s2

and which is defined in the following gist:

Next, we can apply this configuration making sure to include the specified namespace:

k apply -f ./app-config.yaml --namespace ggckad-s2

And the configuration file for the question-two-pod appears below:

We need to apply the pod configuration file, and we do so via the following command:

k apply -f ./question-two-pod.yaml --namespace ggckad-s2

Finally, we need to verify our work.

Verifying Our Solution

Verifying this solution is simple: In step one we'll get CLI access to the container and in step two we'll check the environment, if the environment variables have been set then we're finished.

Step one appears as follows:

k exec -it question-two-pod -c web --namespace ggckad-s2 -- /bin/sh

and step two can be accomplished using the env command and visually inspecting the results.

And that's it for this question.

Question #3

The third question from [1] is as follows:

"All operations in this question should be performed in the ggckad-s2 namespace. Create a pod that has two containers. Both containers should run the kubegoldenguide/alpine-spin:1.0.0 image. The first container should run as user ID 1000, and the second container with user ID 2000. Both containers should use file system group ID 3000."

We need to first create the namespace as per the instructions:

k create namespace ggckad-s2

And the configuration file for the question-three-pod appears below -- review the namespace declaration -- this allows us to apply the configuration file and not include the namespace via the command line (CLI); also, and more importantly, pay particular attention to the fsGroup and runAsUser key/value pairs:

We can apply this configuration as follows:

k apply -f ./question-three-pod.yaml

Finally, we need to verify our work.

Verifying Our Solution

We need to get CLI access to our container and then verify that the settings are correct and the following command can be used to do exactly that:

k exec -it question-three-pod -c alpine-spin-[a or b] --namespace ggckad-s2 -- /bin/sh

Once we have access we can check that the fsGroup and runAsUser key/value pairs have been set correctly -- we'll get this information by using the id command.

And that's it for this question.

Question #4

The fourth question from [1] is as follows:

"All operations in this question should be performed in the ggckad-s4 namespace. This question will require you to create a pod that runs the image kubegoldenguide/question-thirteen. This image is in the main Docker repository at hub.docker.com.

This image is a web server that has a health endpoint served at '/health'. The web server listens on port 8000. (It runs Python’s SimpleHTTPServer.) It returns a 200 status code response when the application is healthy. The application typically takes sixty seconds to start.

Create a pod called question-13-pod to run this application, making sure to define liveness and readiness probes that use this health endpoint."

Unlike previous questions, this one specifically tells us that the kubegoldenguide/question-thirteen image is in the main Docker repository at hub.docker.com. According to the Kubernetes Images:Image Names documentation, "[i]f you don't specify a registry hostname, Kubernetes assumes that you mean the Docker public registry" so no further action is necessary with respect to this detail.

This question specifically requires liveness and readiness probes and we include the definitions of each below for convenience.

Readiness -- "the application is ready to receive traffic" [4]. As per [6]: "[i]f the readiness probe fails, the endpoints controller removes the Pod's IP address from the endpoints of all Services that match the Pod."

Liveness -- "the application is no longer serving requests and K8s will restart the offending pod" [4].

According to the section entitled Define a liveness HTTP request, "[a]ny code greater than or equal to 200 and less than 400 indicates success." -- so no action is required in our solution as the server running in the question-thirteen container will return an HTTP status response code of 200 when the application is healthy.

In our proposed solution, we'll add a buffer and start the livenessProbe at 75 seconds, which is 15 seconds after the typical expected startup time, as indicated in the question four details. The 15 second buffer is an arbitrarily chosen number and the assumption is that, realistically, the server should have been started by this time; a similar example appears in [5] and refer also to [7] and [8].

Note that as of Kubernetes 1.16 it is possible to define a startupProbe such that the livenessProbe will not be started until an initial OK is returned.

Our pod configuration can be seen here.

Finally, we need to verify our work.

Verifying Our Solution

In this example, we should expect to see log messages for the readinessProbe up until ~ 75 seconds after the pod was started, at which point we should see log messages appear for both the readinessProbe as well as the livenessProbe.

kubectl logs question-13-pod -c question-thirteen --v 4 --namespace ggckad-s4

Unfortunately, the output from this command does not tell us which probe is calling the endpoint.

As an exercise for the reader, can we determine exactly which probe is calling the health endpoint? The Kubernetes documentation seems to indicate that this is possible however at this time I do not have an example which demonstrates this.

And that's it for this question.

Question #5

The fifth question from [1] is as follows:

"All operations in this question should be performed in the ggckad-s5 namespace. Create a file called question-5.yaml that declares a deployment in the ggckad-s5 namespace, with six replicas running the nginx:1.7.9 image.

Each pod should have the label app=revproxy. The deployment should have the label client=user. Configure the deployment so that when the deployment is updated, the existing pods are killed off before new pods are created to replace them."

We need to check the labels for both the deployment and pods and then we need to, as per [1] "[c]onfigure the deployment so that when the deployment is updated, the existing pods are killed off before new pods are created to replace them".

We have two deployment strategies available: RollingUpdate (the default), and Recreate [14]. Given the definitions for RollingUpdate and Recreate in this case we do not want to use the default and instead need to assign Recreate to the .spec.strategy.type.

Our deployment configuration can be seen here:

We can apply the file the same as we did in the previous question:

k apply -f ./question-5.yaml

Finally, we need to verify our work.

Verifying Our Solution

We need to check the labels for both the deployment and pods and we also need to ensure that the requirement is met that when the deployment is updated existing pods are killed off before new pods are created to replace them.

We can use the following command to view the deployment labels:

k get deployments --show-labels --namespace ggckad-s5

And we can use the following command to view the various pod labels:

k get pods --show-labels --namespace ggckad-s5

Below we can see the output of applying the question-5.yaml file and then executing these two commands; the yellow arrows show that the labels have been set as per the specification:

Note that our deployment relies on the nginx:1.7.9 image. This image is old so if we update this to nginx:latest and apply the question-5.yaml file again then we see that new containers are deployed while the old containers are gradually terminated. The following image demonstrates this behavior:

Next, we repeat the same exercise only here we check the rollout status using the following command [11]:

kubectl rollout status deployment.v1.apps/question-5 --namespace ggckad-s5

and we can see from a different angle that the old replicas are being terminated while the new ones are starting.

Lastly we can reproduce the same behavior by executing the following command:

kubectl rollout restart deployment question-5 --namespace ggckad-s5

and in this case we don't even need to update the nginx version in the question-5.yaml file.

Let's take a look at an update when the deployment strategy type is set to RollingUpdate -- this is the default and it is also the incorrect choice given the specification.

An Incorrect Solution

The same example but with a RollingUpdate deployment strategy would be incorrect. We include the output of this example below for comparison purposes.

Next, we repeat the same exercise only here we check the rollout status using the following command [11]:

kubectl rollout status deployment.v1.apps/question-5 --namespace ggckad-s5

and we can see from a different angle that the old replicas are being terminated while the new ones are starting.

And that's it for this question, and for this article for that matter -- on to the conclusion!

Conclusion

This article took several hours to write and was done in part as an investigation into how these problems could be solved as an introduction into studying for the CKAD exam for me, specifically.

There are several good articles available if you're beginning the process of preparing for this certification which provide guidance about the test structure and how to study for the exam and I include several links below.

Which Kubernetes certification is right for you?
Certified Kubernetes Application Developer (CKAD) exam preparation tips
How to pass CKAD exam in first attempt ? Tips & Tricks in Kubernetes
CKAD Exam Preparation Study Guide (Certified Kubernetes Application Developer)
CKAD Exam Guide
Be fast with Kubectl 1.19 CKAD/CKA
Practice Enough With These 150 Questions for the CKAD Exam (noted in the comments, apparently these are not questions that would appear on the exam however this is still a good list)

If you have other resources or references that you've found helpful in preparing to sit for this exam, please include them in the comments.

Quiz

Refer to Question 1: Why don't we need to include the specific container in the port-forward command, copied below for convenience, when both the alpine-spin-container as well as the nginx-container both rely on containerPort 80?

kubectl port-forward pods/pod-b 19999:80 --namespace ggckad-s0

Note: port-forward only allows us to specify the pod and not the pod + container.
Refer to Question 1: What would happen if we tried to start pod-b but instead of the alpine-spin-container we had two nginx-container s?
What is the difference between a deployment strategy of "Recreate" juxtaposed with "RollingUpdate"?

Hat Tip

Rishi Malik, Ed McDonald, Aaron Friel, Scott Lowe, and Andy Suderman

References

Hidden Gems: Event-Driven Change Notifications in Relational Databases

Thomas P. Fuller — Sun, 09 Aug 2020 15:46:11 +0000

A powerful non-standard feature that developers should know about

Introduction

Wouldn’t it be great if we could receive event-driven change notifications (EDCN) when data changes directly from the database without having to poll for updates?

This feature is, in fact, available in some relational databases, but not all, as it’s non-standard functionality and not part of any SQL specification.

In the three examples covered in this article, this functionality is expressed via the implementation of an interface that is then registered with the JDBC driver directly. This opens the door to a myriad of potential use cases that can be expressed without the need to poll and which do not require the developer to write infrastructure code to deal with changes in data and notifying interested parties. Instead, we can interface with the driver directly and listen for changes and, when they occur, execute whatever workflow we have in an event-driven fashion. A few examples where this could be helpful include:

Caching (more on this when we cover PostgreSQL, see also Good Candidates for CQN)
Honeypots for database tables — also see poison records
Debugging problems
Logging changes
Analytics and reporting

There are, of course, some consequences when relying on this functionality. The most obvious implication is that it’s a non-standard feature that ties the application directly to the database.

I was speaking with Michael Dürgner on LinkedIn about an example implementation as it pertains to PostgreSQL, and he commented that:

“[W]hile it’s definitely a great way to do this, one of the big drawbacks is that you move application logic into the RDBMS. Not saying you shouldn’t do it but make sure that you have people with deep understanding of the RDBMS you use on board since it’ll be rather unlikely your average software will be able to trouble shoot. Another huge challenge with this approach is continuous delivery since your RDBMS needs to be deeply integrated with your delivery pipeline.”

I agree with Michael’s position, and keeping business logic out of the database tends to be a good practice.

Projects that rely on object-relational mapping (ORM) tools such as the Java Persistence API (JPA) to generate the database schema directly from one or more object models immediately lose portability and simplicity when developers are required to add logic in the database tier which probably belongs in the application itself. If developers are not careful, they’ll end up having to use the same database for testing as used in production and this could easily lead to pain and regret.

I proffer the following question to any engineer considering using EDCNs via the JDBC driver: can the application still function as intended without the inclusion of whatever it is that you’re building that relies on this functionality? If the answer is “yes” then what you’re doing is likely fine; on the contrary, if the answer is “no”, then this is a strike against using EDCNs and alternatives may need to be considered.

Finally, this feature on its own is not a substitute for well-engineered message-oriented middleware (MOM), which typically provides out-of-the-box solutions for guaranteed delivery, message persistence, at-least-once/exactly-once delivery, delivery via queues and topics, strategies for flow control (see also: backpressure), and addresses fault tolerance and scalability concerns. The presence of these requirements could be a strong indicator that an approach relying on EDCNs needs to be reconsidered.

Below we explore this functionality as it exists in the PostgreSQL, Oracle, and H2 databases; we also include some general comments on MySQL and its fork, MariaDB.

Throughout this article, we rely on Java 13.0.2 and Groovy. 3.0.4 and include links to the various scripts on GitHub which contain extra notes pertaining to how to set up the required dependencies and any other preconditions necessary to run the examples.

PostgreSQL

The PostgreSQL (Postgres) database is the first example we’ll examine.

The Postgres API includes the PGNotificationListener interface which must be implemented and then registered with the database connection. Note that there are two implementations of this available: the Postgres [default] JDBC driver and the Impossibl JDBC driver implementation. We do not want to use the Postgres driver, as that implementation will poll the database for changes. Instead, we will rely on the Impossibl implementation, which delivers true event-driven notifications.

I had the opportunity to speak with Erik Brandsberg, CTO of Heimdall Data about this, and Erik remarked that:

“The PG notify interface is one of the hidden gems in PG vs. other databases. We can use it to provide cache invalidation messages between proxies instead of using a distinct pub/sub interface such as on Redis.”

Heimdall Data delivers a sophisticated caching solution for applications that use Amazon Relational Database Service (Amazon RDS) and other databases and this is one real-world use case that demonstrates how important this functionality can be.

In the following example, the trigger and function script must be executed inside Postgres as a precondition to running the Groovy script. The notify_change function will send events to any registered listeners that are listening on the examplechannel channel — pay particular attention to the warning below, as channel names are case sensitive.

A working example implementation of the com.impossibl.postgres.api.jdbc. PGNotificationListener using the PostgreSQL database is included next. The PGNotificationListener interface requires that the developer implement just one method:

void notification(int processId, String channelName, String payload)

We can see this on line #18 below.

We can see an example of this script being executed along with an explanation and the output which appears in the GroovyConsole in the following image.

An explanation of the PostgreSQL example running in the Groovy Console.

The next example we’ll cover includes event-driven change notification functionality as it applies to the Oracle Database.

Oracle

The next example we’ll cover in this article will focus on the Oracle Database (Oracle). Below we detail the steps required to configure event-driven change notifications via the JDBC driver along with preconditions required to run the example.

The following two gists are required preconditions for this example. It is instructive to note that Docker was running on another machine which, in this case, uses the Ubuntu operating system. See the warning regarding running Oracle in Docker locally in the DatabaseChangeListenerInOracleDatabaseExample.groovy script for complete details.

In SQL*Plus, we can now run the following configuration script. Keep in mind that once the example table has been created, see line #8, the Groovy script in the next section can be started and any insert, update, or delete operations on the target table will result in an event being sent to the Groovy script and then printed to the console output.

Here we have an example of the complete DatabaseChangeListenerInOracleDatabaseExample.groovy script. Note that the developer must implement one method:

void onDatabaseChangeNotification(DatabaseChangeEvent databaseChangeEvent)

We can see this implementation on line #55 below.

The following image goes into deeper detail regarding what each step is doing, along with some notes explaining the output.

A deeper explanation regarding what the example script, as it pertains to the Oracle database, is doing, including notes explaining the output.

Lastly, the following image demonstrates that when we perform five inserts in a row and then commit the changes, only a single event is emitted, which includes these five inserts. Events are only ever emitted whenever commit has returned successfully.

Five inserts are executed in SQL*Plus followed by a single commit and we can see that this event includes these five insert operations.

The final example we’ll cover in this article includes the H2 database.

H2 Database

The H2 database is an open-source, lightweight, and very powerful relational database written entirely in Java. It supports a long list of features and ships as a single 2.2mb jar file. H2 is frequently used when testing Java applications and works well as an embedded database and can be used with object-relational mapping tools such as the Java Persistence API (JPA). H2 is also embedded in the JBoss Wildfly application server (JBoss) and has been in use in JBoss as an embedded database for a very long time.

H2 delivers event notifications via the org.h2.api.DatabaseEventListener interface. The DatabaseEventListener interface offers limited functionality when compared with the Postgres and Oracle listener specifications covered earlier. The methods required to implement the interface are:

void closingDatabase () void exceptionThrown(SQLException sqlException, String sql) void init (String url) void opened () void setProgress (String state, String name, int x, int max)

A working example implementation of the org.h2.api.DatabaseEventListener using the H2 database can be found on GitHub and is also included in the gist below followed by an image with pointers explaining how this works.

In this example, H2 is running in embedded mode — that is, H2 is running entirely in memory in the same virtual machine that the Groovy script is running in.

In the following image, we can see an example of this script being executed, along with the output in the GroovyConsole.

An example of the H2 DatabaseEventListener running in the Groovy Console including output.

It’s somewhat disappointing that the H2 DatabaseEventListener doesn’t offer similar functionality to that found in the PostgreSQL interface. As a result, I submitted a new feature request on the H2 Database repository on GitHub and may try to implement this myself, time permitting.

MySQL/MariaDB

Event-driven change notifications via the JDBC driver do not appear to be supported by either MySQL or MariaDB databases and so engineers will have to consider alternative solutions if this functionality is required.

We will not cover triggers and user-defined functions (UDF) as they pertain to MySQL and MariaDB to call a web service endpoint, which is one such alternative. Brief research on this subject suggests that triggers and UDFs can be used to accomplish this; however, they come with potentially significant security and performance implications that must be considered when taking this approach.

If you’ve used triggers and UDFs or some other solution to accomplish this within MySQL and/or MariaDB please feel free to elaborate on what you needed to do, the approach you took, and how well it worked out in the comments. Finally, If there’s a better solution available in MySQL and MariaDB, please explain further.

Conclusion

Have you used event-driven change notifications in relational databases in a project you were on? If so, I encourage you to discuss any of the following in the comments:

What was it needed for?
What database was used?
What language was the solution written in?
Can you do it with Microsoft SQL Server or another database not covered here?
Were any problems encountered, and how were they addressed?
Was this option explored and determined to not be an appropriate solution for the problem at hand?
Were you forced to use an alternative and, if so, what did the implementation look like and why?
Any other thoughts you might have, including any questions I might have left out here.

While EDCNs offer powerful functionality in supported relational databases, we hope that, in addition to providing some working examples, it has also been made clear that there’s a cost associated with relying on this feature and that you must give due consideration before using it.

Happy coding!

Before You Go

If you found this document to be useful, you may also find the Washington, DC Chief Technical Officer Meetup Group to be helpful too. We run events frequently and as these are available over Zoom being local to the DC area is not a requirement.

Demo Friday: Erik Brandsberg reviewed the Heimdall Distributed Database Proxy

Thomas P. Fuller — Thu, 04 Jun 2020 20:37:06 +0000

Click the image above to watch the video on YouTube

On Friday, May 22nd, Erik Brandsberg, Chief Technical Officer at Heimdall Data, reviewed the Heimdall Distributed Database Proxy (HD).

The Heimdall Distributed Database Proxy is a SQL platform for application developers, database administrators, and infrastructure owners.

Whether on-premise or cloud, Heimdall helps organizations deliver faster, more reliable, and secure content generation.

Use Cases:

Find Performance Bottlenecks: Heimdall’s analytics provides complete SQL performance visibility (e.g. slow, redundant queries) and offers recommendations to remediate them. It diagnoses and cures. For deployment there are no application modifications or integration work required for installation.
Increase Scale: Heimdall’s read/write splitting allows customers to make better use of read replicas with ZERO application changes. Heimdall Data is a 5-minute drop-in replacement. Moreover, we guarantee query reads will always have fresh data with our lag detection logic.
Maximize Uptime: Heimdall is application-aware ensuring connection uptime upon a database failover. Why spend resources developing and re-architecting a solution, when you can use Heimdall and install it a matter of minutes.
Strengthen Security: Heimdall provides an added layer of defense, protecting the database from malicious ZERO day attacks. Unlike other solutions, Heimdall’s database firewall does not rely on pattern or signature matching. It is contextual; alerting and filtering SQL queries that are deemed “abnormal”.

Heimdall Architecture

Heimdall Data is a distributed Database Proxy that optimizes from an application perspective. It gives users visibility and control over their SQL environment. Our proxy can be installed anywhere: 1) On each application instance, 2) Separate proxy tier, or 3) On the database. We are transparent to the application and database.

Caching: Today’s SQL solutions incur data latency from application-database round trips. Caching on the database improves scale, but does not remove the latency. The Heimdall proxy can be deployed as a sidecar process across application instances. This distributed model results in optimal performance and predictive scale.

With Heimdall caching, queries that would have gone to the database are now cached locally on the application tier. You choose the cache of choice (e.g. Amazon Elasticache, Redis) and Heimdall determines which query results to cache and invalidate. Best of all, caching does not require writing a single line of code.

Read/Write Split: To scale the database tier horizontally with master and read replicas, applications modifications are required. Heimdall is SQL aware and routes queries to the appropriate database instances (writes or read replicas). As an added benefit, we support replication lag detection to ensure fresh data is always served.

Automated Failover: Health checks each database instance. Upon a failure, Heimdall holds the connection as it transitions to the redundant database instance. This results in failovers that are transparent to the application.

[Sign up to our email list](http://eepurl.com/b5jPPj)

Awesome Backlinks & SEO Workshops

Thomas P. Fuller — Tue, 05 May 2020 19:07:40 +0000

I created a page on GitHub called Awesome Backlinks which has a number of ideas for where backlinks can be created. The purpose, in this case, is focused more on releasing a product or project and gaining awareness for a deliverable. These suggestions could be useful elsewhere, of course.

At this point I have around 16 ideas and intend to expand this list over time.

With that said, what ideas can you share for opportunities to create backlinks?

For convenience, I've included the current list below.

I also host various SEO-related workshops along with discussions on other technical topics online. Register via the Washington, DC CTO Meetup Group if this interests you. As these are held completely via Zoom being local to the DC area is not a requirement.

Add a link on a page from your company website to the project
Add a link on a page from your blog to the project
Twitter (social signal)
LinkedIn Company Updates - Add a URL to the project will be available for indexing (shortened links are considered redirects by Google).
LinkedIn Group Posts - Do NOT count as backlinks but may help to bring awareness to a project.
LinkedIn Personal Posts - Do NOT count as backlinks but may help to bring awareness to a project.
Write an article on _____ and backlink to the project.
- Medium.com
- dev.to
- [WANTED: Other sites here]
Answer questions on Quora and link to the project.
Send email to group mailing lists (project awareness, may be indexed if the mailing list is is archived and publicly available).
Create a video and release it on YouTube and link to the project in the description.
Find appropriate awesome-[x] lists and add a link to your project there.
Find complimentary projects and add the backlink to the README in a "See Also" section or where appropriate. Note that reciprocity is likely welcomed.
Talk about the project in a podcast and request that the project backlink be added in the details.
- [Podcasts WANTED]
Talk at a meetup.com event and request that the project backlink be added in the details.
Post on Facebook (for referral traffic, see also https://monitorbacklinks.com/blog/seo/facebook-backlinks )
Showcase the project including the backlink on Google My Business

How to Prepare for the AWS Certified Solutions Architect: Associate Certification Exam

Thomas P. Fuller — Fri, 31 Jan 2020 22:29:15 +0000

TL;DR: Take a course online, use flash cards, and take as many practice exams as possible (17 quizzes, exams, and practice tests are included below, see the *'s).

In this article I include several observations based on my experience preparing to take the AWS Certified Solutions Architect: Associate Certification Exam‎ -- if you are planning to sit for this exam hopefully you will find the following pointers to be helpful.

In my opinion, practice exams and tests are a very important tool to use when studying for this exam and this article includes 17 links to exams, quizzes, and tests to assist you in your effort [see *'s].

🎓 The test is not hard but it's not easy either, so expect to study. I would recommend first taking a practice exam and seeing how you do and then setting a date to take the actual exam which is not too far in the future. Once you've completed a practice exam you'll be able to see where you're weak and then you can dedicate extra effort on those domains that require attention.

Then study with the intention of sitting for the exam on that date.

You could even lock yourself in by scheduling the exam before you begin studying for it in earnest.

From AWS Certified Solutions Architect –
Associate (SA1-C01) Exam Blueprint, the test is broken down as follows (note the links below point to subject-specific practice assessments which may be helpful):

Domain	% of Scored Items
Domain 1: Design Resilient Architectures *	34%
Domain 2: Define Performant Architectures *	24%
Domain 3: Specify Secure Applications and Architectures *	26%
Domain 4: Design Cost-Optimized Architectures *	10%
Domain 5: Define Operationally Excellent Architectures *	6%

You should also become acquainted with the The 5 Pillars of the AWS Well-Architected Framework which includes operational excellence, security, reliability, performance efficiency, and cost optimization.

The Prepare for Your AWS Certification Exam * page includes more sample questions, another practice exam, and further information.

🎓 Take courses online, especially courses that have practice exams and I've included two courses for your consideration below.

Ultimate AWS Certified Solutions Architect Associate 2020 * includes one practice exam.

AWS Certified Solutions Architect Associate Practice Exams * includes six practice exams.

Further example tests and questions can be found in [3, 4, 5, and 11 *].

In my opinion, as long as you're motivated it should not be necessary to take classroom training in order to pass this exam. Keep in mind, however, that I have been developing software for ~ 20 years at the time of this writing and I have experience with AWS as well. People who are new to AWS or who are unfamiliar with the concepts may benefit from classroom-based training.

🎓 YouTube has many excellent videos on this subject and below I've added three to this article, see [8, 9, 10]. If you find that you're weak on a given topic YouTube will likely have videos that can compliment the other material you're relying on to prepare for this exam.

🎓 Some questions revolve around corner cases & details which are easy to answer with Google, but you won't have Google available when you take the exam so it's important to know these corner cases because these questions are usually easy to answer once you understand the nuance.

🎓 You'll need to pace yourself properly otherwise you'll run low on time and end up needing to rush through questions to complete the exam, and that's not a good place to be.

The test consists of 65 multiple choice questions and 130 minutes to complete the test, this means you have two minutes per question; a score of 72% or better is passing.

Some questions will require that the test taker select more than one possible answer.

The test software will allow you to mark questions and return to them later so if you find that you're spending too much time on something, do the best you can with it, mark it, and move on -- you can return to it later if you have time remaining.

🎓 Consider using flash cards and when you get a question wrong on a practice test, for example, add the gist of information that you missed framed as a question to the flash card and review it daily. There's significant ground covered so you may have a stack of these eventually.

I am not the only person to suggest using flash cards — for example, in the article entitled “How I Passed a Cloud Provider Certification Exam in Less Than 3 Weeks” [14] the author, Joshua Feierman, states that “…good old flashcard[s are] actually way more effective than reviewing your notes and highlights. To that end, one of the ways I studied for the [AWS DevOps Engineer Professional] exam was using the free online tool Quizlet, which allows you to create decks of flashcards and use various ways to review them (hint: the “Learn” mode was probably the best method I found)”. In my preparation I used simple paper flash cards so choose what works for you.

If you find that you are weak on a specific subject then you should spend time reviewing missed questions, covering subject-specific material such as videos on S3 for example, that will help bridge gaps in knowledge, while reviewing your stack of flash cards so that you're constantly re-testing yourself.

I found that a notebook is only marginally helpful when studying for this exam mainly because the notebook did not help me drill and when it comes to multiple choice tests reviewing material, for me at least, is not as helpful as drilling with that material.

🎓 Learn to identify answers which are clearly wrong and make sure to understand why.

🎓 Identify answers to questions which were answered correctly while not fully understanding why.

This is an important point when reviewing the results of a practice exam: it is important to understand why a question was answered incorrectly but that should not be the only focus because there will likely be guesses which are correct and it will behoove you as much to study these questions as well.

When I took practice exams I would write on paper which questions I had to guess on so I knew which ones to pay particular attention to once the results were available.

🎓 At some point you'll have to go for it and see how you do so good luck!

🎯 Once I passed the AWS solutions architect associate exam I received a 50% off voucher for recertification or any other exam.

If you've passed this exam & have additional suggestions to add, please include them in the comments.

This article has been reposted from LinkedIn -- feel free to add your thoughts below, or on LinkedIn. And feel free to send me an invitation to connect, if you'd like to network.

The Power of Pair Programming, Pair Rotation, and Mobbing for Extreme Collaboration

Thomas P. Fuller — Fri, 17 Jan 2020 20:11:17 +0000

TL;DR: Use pair programming, pair rotation, and mobbing to help create a more cohesive team, where information is shared freely amongst the group, and one with a better view of the overall mission of the project.

I worked on a ten week contract recently with a group of excellent software engineers and one of the strategies of software development that I had the pleasure of experiencing on this gig was the incorporation of pair programming, pair rotation, and mobbing -- the result of this included an impressive amount of work being delivered in a relatively short period of time. It also led to a more cohesive team, one where information flowed freely amongst the group, and one with a better view of the overall mission.

A brief summary of this project is that it was technically challenging work, where we took an existing Java-based monolithic web application and transformed it into an application following a microservices architecture and running in Kubernetes on AWS.

I have encountered pair programming in the past. In 2001 I worked on a project where we chose to follow this technique for developing software and we had an excellent return on investment. Sadly, this rarely shows up on projects I've worked on since then. While I've seen variations of mobbing or mob programming, pair rotation was new.

A byproduct of working in this manner includes no code ownership, no problem ownership, and there's no single person left struggling with a problem for long periods of time, nor are there gaps in understanding of what or why something was done a certain way, nor was there a need to perform a knowledge transfer exercise at the end of the project because everyone was working on the same thing at the same time.

This way of working is likely to have its detractors [#5, #6, and #7]. Already I can predict that the rebuttal being that if two people are working on the same problem that means that there are two brains doing one thing when they could be doing two -- sure they could but it'll take longer than if two people focus on one thing and then blow through it and start on the next task. Also there are two people who can explain why something was done a certain way, and that's important because people forget, people leave projects, etc. If a single task has one rotation you'll end up with three people who understand what was done.

One may also assume that switching developers halfway into a problem would slow the whole operation down as well but in my experience this is not the case at all. Firstly we would only rotate one of a two person team off of a task at any one time, and secondly it only took a few minutes for people to get acclimated with where the task was at that point and then start contributing to the solution. Finally, this strategy kept things interesting, allowing developers to work on areas of the application which they may not have had a chance to do if they were focused only on one area of the application for long periods of time, and this strategy also helped to prevent burnout.

As an aside, we didn't pair for the entire day -- in some cases we would break off and work on something individually and then bring that finding or subtask back to the task at hand and incorporate the result.

Finally, mobbing really helped to push through particularly difficult pain points and at one point we had five people working towards getting a task resolved. This was an excellent approach as the problem we had required an understanding of a certain framework and we had an expert available on the team. We had the symptoms already identified, we voiced the observations during our daily standup meeting, and when this happened we were able, as a group which now included yet another engineer, to get this problem resolved in under three hours. Compare this with working on this issue in an insular manner or with only a short burst of assistance here and there and it could have easily taken two weeks to get past this issue alone and the task itself was technically challenging.

All in all this experience was positive and I often left work at the end of the day feeling exhausted but also consistently productive, and that's very important since one is not far from burning out when they're going home day after day feeling exclusively exhausted.

So have you tried pair programming, pair rotation, and mobbing on any of the projects you've worked on? If so, I'd be interested to hear if your experience reflects what I've written in this article, so please include some comments below. I'd be especially interested in hearing where this hasn't worked, or any problem encountered when introducing this style of working.

Addendum

I had the pleasure of chatting with Benjamin Smith, a member of CTO Lunches, a few days ago and here's what Ben had to say about pair programming:

I've been pairing full time in most of my gigs for the past 10 years...

Pairing encourages doing the right thing. Most teams see this come out in higher quality code, but it applies to anything. Are you more likely to write that test first when you're by yourself or when your peer is sitting next to you? If testing is difficult for you, you might skip writing the test first or skip writing tests altogether if you are soloing. How about talking to the stakeholders to get a better understanding of what needs to be built rather than just making assumptions and carrying on? Or spending the time to figure out the performance implications of a SQL query rather than just shipping it as is.

Full time pairing removes your ego. When I'm soloing I occasionally (maybe often) get stumped by simple problems. They're problems that I know I should be able to solve, and I know the solution is going to be face-palm stupid. I will spin my wheels for 15 minutes, then 30, and feel embarrassed when I have to ask for help after 45 minutes. My Ego is what's making me feel embarrassed, and keeping me from asking for help the second I get stuck. With full time pairing, you cannot have any ego. If you get stuck or don't know something, you cannot hide it. You get used to saying "I don't know". And when your pair replies with "I don't know either", you immediately get up and find someone to help the two of you rather than waiting 45 minutes. (as a side note: I don't believe that teams that pair part time, or pair-when-it-makes-sense are able to get rid of the above ego problem).

When choosing whom will pair with whom on the team, all different match ups are productive. For example you may think that it is always a good idea to keep a junior team member paired with a senior team member, but that's not actually the case. It is equally good to have two junior people pair up and work their way through hard problems on their own.

Pairing when neither person knows tech stack can be tough. For example: if the codebase is in React, and neither have ever done any React, then you spend your time going through tutorials, and reading documentation. Reading through large amounts of text while pairing is hard since everyone reads at a different speed.

Those are a few nuggets that immediately come to mind."

References

COBOL is dead...or is it? 😳

Thomas P. Fuller — Thu, 02 Jan 2020 19:12:14 +0000

An acquaintance was surprised to learn recently that the COBOL business programming language, created ~ 1959, was still in use in 2019.

In fact COBOL is still prolific and won't be going away any time soon, if ever.

Below are several observations which demonstrate that COBOL is still alive and well today.

✔️ Companies are still actively hiring COBOL developers [1]. LinkedIn, for example, has 2075 COBOL jobs open in the US today.
✔️ The national average for a senior COBOL developer is ~ $110k [2].
✔️ COBOL has been object oriented since 2002 [3].
✔️ GitHub has 1558 COBOL repositories [4].
✔️ The LinkedIn Mainframe Experts Network has ~ 32k members [5a].
✔️ The LinkedIn Mainframe Experts Group, which includes COBOL, has ~ 47.6k members [5b].
✔️ There are 173 groups in total on LinkedIn which include COBOL.
✔️ Micro Focus offers JVM COBOL support [6].
✔️ The Oracle GraalVM supports COBOL [7].
✔️ The Microsoft Visual Studio 2015 IDE supports COBOL [8].
✔️ COBOL code can be run on AWS Lambda [9].
✔️ Per [10 & 11] 25k+ companies use COBOL.
✔️ In 2017 Reuters calculated that there was still 220bn lines of COBOL code running in production & COBOL systems handled $3 trillion in commerce every day [12].

If you have additional points please add your thoughts in the comments section.

References

[1] https://enterprisersproject.com/article/2018/11/3-aging-it-specialties-just-won-t-retire
[2] https://www.ziprecruiter.com/Salaries/Senior-Cobol-Developer-Salary
[3] https://en.wikipedia.org/wiki/COBOL
[4] https://github.com/search?q=cobol
[5a] https://www.linkedin.com/groups/55779/
[5b] https://www.linkedin.com/groups/910927/
[6] https://www.microfocus.com/documentation/visual-cobol/VC40/EclWin/GUID-DEAFFCA6-6D75-4AEA-A3B6-6DF0BDCF3E2F.html
[7] https://www.graalvm.org/uploads/graalvm-language-level-virtualization-oracle-tech-papers.pdf
[8] https://blogs.msdn.microsoft.com/cdndevs/2015/09/09/visual-studio-2015-now-supports-cobol-and-you-can-make-desktop-and-web-apps-with-it/
[9] https://searchaws.techtarget.com/news/252454023/COBOL-applications-can-go-serverless-on-AWS-Lambda
[10] "Companies using COBOL"
[12] https://thenewstack.io/cobol-everywhere-will-maintain/