Forem: Coherent Logic Limited

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.

Five tips for passing the AWS Machine Learning specialty exam - A data scientist perspective

Wendy Wong — Wed, 29 Jan 2020 21:59:15 +0000

I recently passed the AWS Machine Learning Specialty exam and received quite a few questions on how to prepare for it. So I thought I would write a few tips from a data scientist perspective. This is by no means a comprehensive AWS ML exam guide; rather, I focused on the several areas that I feel that I should not lose any points, or I often got them wrong in practice exams.

The exam guide from AWS says you will be tested on four domains: Data Engineering, Exploratory Data Analysis, Modeling, and Machine Learning Implementations and Operations. The Modeling portion is worth 36% of the entire exam; this is the section that tests your practical machine learning knowledge in applying the right ML solution to a real-world business problem. Also, being an AWS exam, this section has a lot of questions on SageMaker and other AWS ML services.

I purchased this course on udemy by Frank Kan and Stephane Maarek and found it to be very helpful. I actually found this exam required much less preparation than the AWS solutions architect associate exam that I passed last spring, mainly because I work on ML problems on a daily basis as a data scientist, and I generally do not have to worry too much about setting up networks and security. So, if you have a similar background like me, the AWS ML exam is worth taking. The preparation would help you get a better understanding of what AWS offers. Here I summarize five tips that may help you pass the ML exam:

1. Know your distributions

This is really the basic knowledge of statistics/machine learning. You will get tested on them, and you should be able to answer these quickly. The question will explain a scenario and ask you which distribution would best describe it. As a statistics major, these are questions that I found the easiest, but it also means that you should not lose any points on these questions --- since other exam takers probably also get full scores in these.

2. The Amazon Kinesis Family

If you are like me, who is more used to handle "offline" datasets, you may not have experience in dealing with real-time data, which is what the AWS Kinesis family of tools is about. The kinesis family of services, together with AWS Glue, will make up the majority of the data engineering domain (20%) of the ML test. I summarize a few key points that confused me in the beginning:

Only Kinesis Data Firehose can load streaming data into S3; it can also provide data compression (for S3), as well as data conversions to Parquet/ORC.
While Kinesis Data Firehose cannot provide data transformation (such as CSV->JSON), it can do so via AWS Lambda.
Kinesis Analytics is mainly used for real-time analytics via SQL; there are two custom AWS ML SQL functions: RANDOM_CUT_FOREST (for detecting anomaly) and HOTSPOTS (for identifying dense regions).
Kinesis Analytics will use IAM permissions to access streaming sources and destinations.
There is also S3 analytics, which is not to be confused with Kinesis Analytics. S3 Analytics is used for storage class analysis.

3. AWS Glue

AWS Glue is another AWS tool that I like --- I just think it is so cool that it automatically crawls my parquet files on S3 and automatically generates a schema. When we have a large amount of data in Parquet hosted on S3, it was very convenient to query Glue generated Athena tables for data exploration. I discovered a few more tricks that Glue can do when I was studying for the exam:

In addition to the standard data transformation such as DropFields, filter, and join, it also comes with an AWS custom algorithm FindMatches ML, which identifies potential duplicated records, even though the two records may not match exactly.
Glue will set up elastic network interfaces to enable the job to connect to other resources securely
Glue can run Spark jobs, and it supports both Python 2.7 and Python 3.6.

4. Security

Again, your mileage may vary, but for me, I am more used to be told by IT that I can't do this or that due to security concerns, rather than having to worry about it too much myself. While the ML exam does not have as many questions on security as the solutions architect exam, you don't want to lose points on this. At a minimum, you will need to know security works with AWS S3; also, security around using SageMaker, how to protect your data to and from SageMaker.

5. Amazon SageMaker

I have some experience with Amazon SageMaker and love it for making a few things very convenient, such as providing the most popular ML frameworks pre-installed in containers. I just don't love its cost that much but, I digress 😔. Amazon SageMaker, being the flagship AWS fully managed ML service, will be tested heavily in the ML exam. Other than security that I mentioned above, some of the things you will need to know include:

Understand all built-in algorithms from SageMaker; you will be tested on these! Also, understand which algorithm can be speeded up by multi-core, multi-instance, or GPU.
SageMaker can only get its data from S3, and there's pipe mode or file mode; usually, pipe mode speeds up things when the data is very large.
Hyperparameter tuning in SageMaker, understand what the options are, and understand how automatic model tuning works with SageMaker.
Knowing that using Amazon Elastic Inference (EI) with an Amazon SageMaker hosted endpoint can speed up inference time, but you can only attach the EI during instance launch and not after deployment.

Additional Tip: Take two exams for the price of one

From the cost perspective, I would also recommend taking the AWS solutions architect associate certification exam before you take the machine learning specialty one (that's what I did). The AWS solutions architect associate exam costs $150, and after you pass the exam, you will receive a coupon for half price for your next exam. The AWS Machine Learning Specialty exam is $300 and would be $150 after applying the discount. So for $300 you could get both AWS certificates! Good luck!

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/

Forem: Coherent Logic Limited

Answers to Five Kubernetes CKAD Practice Questions (2021)

Question #1

Verifying Our Solution

Question #2

Verifying Our Solution

Question #3

Verifying Our Solution

Question #4

Verifying Our Solution

Question #5

Verifying Our Solution

An Incorrect Solution

Conclusion

Quiz

Hat Tip

References

Hidden Gems: Event-Driven Change Notifications in Relational Databases

A powerful non-standard feature that developers should know about

Introduction

PostgreSQL

Oracle

H2 Database

MySQL/MariaDB

Conclusion

Before You Go

Demo Friday: Erik Brandsberg reviewed the Heimdall Distributed Database Proxy

Heimdall Architecture

Awesome Backlinks & SEO Workshops

See Also

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

See Also

Five tips for passing the AWS Machine Learning specialty exam - A data scientist perspective

1. Know your distributions

2. The Amazon Kinesis Family

3. AWS Glue

4. Security

5. Amazon SageMaker

Additional Tip: Take two exams for the price of one

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

Addendum

References

COBOL is dead...or is it? 😳

References