DEV Community: Scott Gordon

Kubernetes Simplified: Embarking on the Zero to Hero Journey - Part 2

Scott Gordon — Wed, 13 Mar 2024 00:01:46 +0000

In the previous post, we discussed the basics of Kubernetes and containerization. In this post, we will continue our journey and explore some best practices for deploying and managing containerized applications using Kubernetes.

Namespaces

Namespaces are a way to divide cluster resources between multiple users or teams. They provide a scope for names, which helps avoid naming conflicts. By using namespaces, you can create a logical separation between different parts of your application.

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace

Readiness and Liveness Probes

Readiness and liveness probes are essential for ensuring that your application is running correctly. Readiness probes check if your application is ready to receive traffic, while liveness probes check if your application is still running. By using these probes, you can ensure that your application is always available.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: my-image
    readinessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 15
      periodSeconds: 20

Autoscaling

Autoscaling allows you to automatically adjust the number of replicas of your application based on demand. This ensures that your application can handle traffic spikes without manual intervention.

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: my-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-deployment
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50

Resource Requests and Limits

Resource requests and limits allow you to specify the amount of CPU and memory that your application needs. By using these, you can ensure that your application has enough resources to run correctly.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: my-image
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 200m
        memory: 256Mi

Deploying Your Pods

Deploying your Pods as part of a Deployment, DaemonSet, ReplicaSet or StatefulSet across nodes ensures that your application is highly available and fault-tolerant.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-container
        image: my-image

Multiple Nodes

Using multiple nodes ensures that your application can handle traffic spikes and is highly available.

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
  - name: http
    port: 80
    targetPort: 8080
  type: LoadBalancer

Role-based Access Control (RBAC)

RBAC allows you to control access to your Kubernetes resources. By using RBAC, you can ensure that only authorized users have access to your resources.

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: my-role
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: my-role-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: my-role
subjects:
- kind: User
  name: my-user

Hosting Your Kubernetes Cluster Externally

Hosting your Kubernetes cluster externally using a cloud provider ensures that your application is highly available and fault-tolerant.

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
  - name: http
    port: 80
    targetPort: 8080
  type: Load

Conclusion

In this post, we explored some best practices for deploying and managing containerized applications using Kubernetes. By following these best practices, you can ensure that your application is highly available, fault-tolerant, and always running smoothly.

Photo by Growtika on Unsplash

Kubernetes Simplified: Embarking on the Zero to Hero Journey

Scott Gordon — Wed, 06 Mar 2024 15:42:45 +0000

What is Kubernetes?

Introduction

In today's fast-paced tech environment, the ability to deploy, manage, and scale applications efficiently is crucial. Kubernetes, often stylized as K8s, stands at the forefront of this challenge, offering powerful solutions for managing containerized applications across various computing environments.

Containerization and Kubernetes

Before diving into Kubernetes, it's essential to understand the concept of containerization. Containerization allows developers to package applications with their dependencies and configurations, facilitating consistent deployments across different computing environments. This is where Kubernetes comes into play.

Kubernetes: The Container Orchestrator

Kubernetes is an open-source platform designed to automate the deployment, scaling, and operation of application containers. It provides the infrastructure to build a container-centric development environment. Kubernetes simplifies many aspects of managing containerized applications, including:

Automated rollouts and rollbacks: Kubernetes enables you to describe the desired state for your deployed containers using declarative configuration files, and it can change the actual state to the desired state at a controlled rate. For example, you can automate Kubernetes to create new containers for your deployment, remove existing containers, and adopt all their resources to the new container.
Scaling: With Kubernetes, you can scale your application up or down with a simple command, a UI, or automatically based on CPU usage.
Service discovery and Load balancing: Kubernetes can expose a container using the DNS name or using their own IP address. If traffic to a container is high, Kubernetes is able to load balance and distribute the network traffic so that the deployment is stable.
Self-healing: Kubernetes restarts containers that fail, replaces containers, kills containers that don't respond to your user-defined health check, and doesn't advertise them to clients until they are ready to serve.

Why Kubernetes?

Kubernetes has become the go-to orchestrator for containers due to its efficiency, scalability, and developer-friendly features. Organizations of all sizes from startups to global enterprises, have embraced Kubernetes to manage their containerized workloads and services.

Kubernetes helps with:

Flexibility: Whether you're running applications on-premises, in the cloud, or in a hybrid environment, Kubernetes has you covered.
Efficiency: By optimizing the use of hardware resources to run your services, Kubernetes can significantly reduce infrastructure costs.
Velocity: Kubernetes accelerates development, testing, and deployment cycles, enabling teams to focus on building their applications rather than managing the underlying infrastructure.

In conclusion, Kubernetes is not just a tool but a comprehensive ecosystem that supports your applications' deployment, scalability, and management needs. Its widespread adoption and supportive community make it a critical component of modern software development and operations.

Mastering Your Digital Toolbox: Setting Up JFrog Artifactory with Terraform

Scott Gordon — Mon, 04 Mar 2024 04:57:30 +0000

Repo

Welcome to the digital craftsman's workshop, where tools and materials are paramount to creating masterpieces. Today, we're diving into setting up JFrog Artifactory using Terraform, akin to organizing your workshop with the best tools for your projects. Imagine Terraform as your smart toolbox that knows exactly where each tool should go and Artifactory as the ultimate storage cabinet for all your project materials, ensuring they're safe, organized, and easily accessible.

Introduction: The Craft of Infrastructure

In the realm of software development and operations, efficiency and organization are key. Just as a well-organized workshop allows a craftsman to work wonders, a well-set-up Artifactory server can streamline your CI/CD pipeline, akin to having a magical materials cupboard that presents you with exactly what you need, when you need it.

Terraform: The Smart Toolbox

Imagine you have a smart toolbox that not only holds your tools but also knows where in the workshop each tool should go. That's Terraform for you. With it, you can script the setup of your entire workshop (infrastructure), ensuring that everything is placed precisely where it should be, every time you set up a new shop.

Step 1: Crafting Your Workshop Layout

First, we layout our workshop. In Terraform, this involves creating a plan or script that describes where everything goes. We start with the foundation: setting up an Artifactory server, much like deciding where to place your storage cabinet for easy access.

# The foundation: Setting up an AWS EC2 instance for Artifactory
resource "aws_instance" "artifactory_server" {
  ami           = var.artifactory_ami_id
  instance_type = "m5.2xlarge"
  key_name      = var.key_name

  # Define the location and size of our cabinet (instance storage and type)
  root_block_device {
    volume_size = 300
    volume_type = "gp3"
  }
}

Step 2: Securing Your Workshop

No workshop is complete without proper security measures. In our digital workshop, this means setting up security groups to control who can access the Artifactory server. Imagine this as installing a sturdy lock on your storage cabinet.

# Security measures: Defining who can access our materials
resource "aws_security_group" "artifactory_sg" {
  ingress {
    from_port   = 8081
    to_port     = 8081
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # Locks and keys: Only let the right people in
}

Step 3: Organizing Your Materials (Artifacts)

With JFrog Artifactory acting as our cabinet, we use Terraform to ensure it’s well-organized, making artifacts easy to find, store, and secure. This is like meticulously labeling every drawer and shelf in your storage cabinet.

JFrog Artifactory: The Ultimate Storage Cabinet

Why is Artifactory akin to a magical storage cabinet? It’s because it can hold virtually any kind of "material" (artifact) you might need for your projects: Docker images, npm packages, or even Terraform modules themselves.

Integrating Terraform and Artifactory

Integrating Terraform with Artifactory is like setting up a system where your toolbox automatically updates your storage cabinet with the right materials whenever you start a new project. This ensures your CI/CD pipeline has everything it needs, precisely when it's needed, without manual intervention.

Conclusion: A Workshop That Works for You

By setting up JFrog Artifactory with Terraform, you're not just organizing your digital workshop; you're empowering it to be more efficient, secure, and capable of handling projects of any size. It's like having a workshop that evolves with you, always ready for the next masterpiece you're set to create.

And there you have it, a well-organized, efficient, and secure digital workshop setup with JFrog Artifactory and Terraform. Just as a craftsman relies on their workshop to bring creations to life, you can rely on this setup to streamline your development and operations processes, making it easier to manage, deploy, and scale your applications.

Remember, the best workshops are those that are well-organized, adaptable, and secure. With Terraform and Artifactory, you're well on your way to achieving just that in the digital realm. Happy crafting!

Photo by Barn Images on Unsplash

Building a Cloud Infrastructure with Terraform: A Real-World Guide

Scott Gordon — Sun, 03 Mar 2024 05:36:57 +0000

Demo Repo

Welcome to our journey through the cloud, where we’ll build our infrastructure using Terraform as if we were constructing a city from the ground up. If you’ve ever played a city-building game or marveled at the intricacies of urban planning, you’re in for a treat. Let’s translate that fascination into the digital realm of cloud infrastructure.

Introduction

In this tutorial, we're going to construct our digital metropolis using Terraform, a powerful tool that lets us define our city (infrastructure) as code. Just like city planners need to map out where buildings, roads, and parks go, we’ll plan where our servers, networks, and services reside in the cloud.

Prerequisites

Before we break ground:

Ensure you have Terraform installed. Think of this as getting your construction tools ready.
An AWS account is like owning the land where we’ll build our city.
Basic knowledge of cloud concepts – akin to understanding what buildings, roads, and utilities are in urban planning.

Step 1: Laying the Groundwork with Our VPC

Our first task is to establish the land boundaries for our city, known as a Virtual Private Cloud (VPC) in AWS.

resource "aws_vpc" "main" {
  cidr_block           = "10.0.1.0/16"
  enable_dns_support   = true
  enable_dns_hostnames = true
  tags = {
    Name = "Main VPC"
  }
}

Explanation

cidr_block defines the size of our land. Imagine it as deciding how big our city will be.
Enabling DNS support and hostnames is like ensuring our city has a postal service, making it easier to find addresses.

Step 2: Building the Roads (Subnets)

Just as roads connect different parts of the city, subnets connect sections of our cloud city, guiding traffic to its destination.

resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "us-east-1a"
  map_public_ip_on_launch = true
  tags = {
    Name = "Public Subnet 1"
  }
}

Explanation

Each aws_subnet represents a neighborhood. The cidr_block specifies the neighborhood's size.
map_public_ip_on_launch ensures every home (server) in our public neighborhood has a street address (IP) visible to the world.

Step 3: Powering Our City (Internet Gateway)

An Internet Gateway in our cloud city acts like a highway to the outside world, allowing data to flow in and out.

resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id
}

Explanation

Attaching this to our VPC is akin to building a major highway from our city to the rest of the world, vital for trade and communication.

Step 4: Constructing Buildings (EC2 Instances)

Now, we’re ready to build our structures: the servers where our applications live. These are our city’s buildings, each serving a unique purpose – from housing residents (data) to providing services (applications).

module "ec2" {
  source = "./modules/ec2"
  // Pass in required variables like AMI ID, instance type, etc.
}

Explanation

Each EC2 instance is a building, designed for a specific use. The instance type determines the building size and capacity.

Step 5: Opening Public Spaces (ALB)

An Application Load Balancer (ALB) acts like a city’s public square, directing visitors to various buildings (servers) based on what services they need.

module "alb" {
  source = "./modules/alb"
  // Configuration details
}

Explanation

The ALB ensures that no single building gets overcrowded, distributing incoming traffic evenly. It’s like having traffic lights and signs in our public square.

Wrapping Up

Congratulations! You’ve laid the foundations of your cloud city, built its infrastructure, and opened it to the public. Like any city planner, your job is ongoing. You’ll need to manage, expand, and adjust the city as it grows. Terraform makes these tasks manageable, allowing you to adapt your infrastructure to meet the needs of its inhabitants.

Remember, every great city started with a plan. Your cloud infrastructure is no different. Happy building!

Photo by shawnanggg on Unsplash

LEGO 3D Coordinates

Scott Gordon — Fri, 01 Mar 2024 16:38:06 +0000

The Grid Dimensions

Length (X): The number of blocks you can place in a row.
Width (Y): The number of blocks you can place in a column, perpendicular to the row.
Height (Z): The number of layers of blocks you can stack on top of each other.

Imagine you have a LEGO base that's 1 block wide, 1 block long, and you're allowed to stack up to 1 block high. This gives you a tiny (2 X 2 X 2) space to work with, because you start counting from 0 (so you have positions 0 and 1 in each dimension).

The Rule (N)

Now, let's say you have a rule: You can't place a LEGO block at any position where the sum of the coordinate's equals (N). For instance, if (N=2), you can't place a block at any spot where adding up the row number, column number, and stack height equals 2.

Visualizing Coordinates

Each spot where you could place a LEGO block has coordinates (i, j, k):

(i) is the position along the length of your base.
(j) is the position along the width.
(k) is the height or layer number.

Real-World Example

Let's apply this with our (1 X 1 X 1) model and (N=2):

You start placing blocks at (0, 0, 0), the very bottom corner.
You can also place blocks at (0, 0, 1), moving up one layer without changing the row or column.
However, you can't place a block at (0, 1, 1) because (0+1+1=2), and our rule forbids any spot where the coordinates add up to 2.

The List of Allowed Coordinates

Using a list comprehension to apply these rules, we find the allowed spots to place our LEGO blocks without breaking the (N=2) rule. For our tiny LEGO base, the possible placements, avoiding spots where the sum equals 2, might look like this: [(0, 0, 0), (0, 1, 0), (1, 0, 0), (1, 1, 1)]. Each of these coordinates represents a spot where you can safely place a block according to the rules.

Visualization

Imagine laying out a grid of possible block positions on your LEGO base and then marking which spots are allowed under the rule. Each allowed spot gets a LEGO block, building a unique structure that adheres to your constraints.

This visualization takes the abstract concept of 3D coordinates and the rule-based exclusion and turns it into a tangible LEGO building exercise, making it easier to grasp how list comprehensions can generate and filter complex collections based on specific conditions.

Here is the code in Python using a list comprehension.

#!/usr/bin/python3
# lego_3d_coords.py

def lego_3d_coordinates(x, y, z, n):
    """
    This function will print all possible coordinates on the 3D grid within the
    specified dimensions, excluding those combinations where the sum of the dimenstions
    equals 'n'
    """
    coordinates = [[i, j, k] for i in range(x+1) for j in range(y+1) for k in range(z+1) if i + j + k != n]
    print(coordinates)

if __name__ == '__main__':
    x = int(input())
    y = int(input())
    z = int(input())
    n = int(input())
    lego_3d_coordinates(x, y, z, n)

Once you have created this script be sure to make it executable using chmod +x lego_3d_coords.py then run it in the same directory using ./lego_3d_coords.py

Also remember to add the coordinates input values using your preferred CLI once you run your Python script.

Photo by Xavi Cabrera on Unsplash

Nagios for DevOps Beginners: A Simple Guide to Effective Monitoring

Scott Gordon — Wed, 28 Feb 2024 02:11:39 +0000

Hey, fellow DevOps enthusiasts! Today, we're diving into the wonderfully complex world of Nagios. Think of Nagios as that overly attentive friend who never misses a beat, always keeping an eye out to ensure everything runs smoothly in your infrastructure. Whether you've just stumbled upon the realm of monitoring or you're a seasoned engineer looking for a refresher, this guide is tailor-made for you.

What is Nagios?

Nagios is an open-source monitoring system that helps you keep an eye on your IT infrastructure, ensuring your systems, applications, services, and business processes are running like a well-oiled machine. It's like having a guardian angel for your network, minus the wings and halo.

Why Nagios?

Comprehensive Monitoring: From servers to network protocols, and applications, Nagios doesn't let anything slip past it.
Proactive Problem Resolution: It notifies you before your coffee gets cold, helping you fix issues before they become real problems.
Customizable: With Nagios, you're the artist, and your IT infrastructure is your canvas. Customize it to your heart's content.

Getting Started with Nagios

Here's how to set up your monitoring station without pulling all your hair out:

Step 1: Installation

Nagios runs on Linux, so if you're on Windows, consider this an opportunity to get cozy with Linux. You can install Nagios on most distributions with a few commands. For example, on Ubuntu:

sudo apt update
sudo apt install nagios4 nagios-plugins-contrib nagios-nrpe-plugin

Remember, Google is your friend if you're using a different distribution. Or Bing, if you're feeling adventurous.

Step 2: Configuration

Nagios speaks in the language of configuration files. You'll find these in /etc/nagios4. The main file to be aware of is nagios.cfg, but the real MVPs (Most Valuable Files) are the ones in the conf.d directory.

Hosts and Services

To monitor a server, you need to define it as a host. To monitor specific aspects of that server, like CPU usage or disk space, you define services. Here's a quick example:

define host{
        use                     linux-server
        host_name               myserver
        alias                   My First Server
        address                 192.168.1.100
        }

And for a service:

define service{
        use                             generic-service
        host_name                       myserver
        service_description             Ping
        check_command                   check_ping!100.0,20%!500.0,60%
        }

Step 3: Monitoring

After you've set up your hosts and services, it's time to let Nagios do its magic. Restart the Nagios service, and then log into the Nagios web interface (usually at http://yourserver/nagios) with your credentials.

Step 4: Reacting to Alerts

When Nagios detects a problem, it will send you an alert. This is your cue to jump into action. Depending on the severity, you might need to SSH into the affected server, check logs, or perform some troubleshooting magic.

Best Practices

Keep it Organized: As your infrastructure grows, so will your Nagios configuration. Keep things tidy.
Document: Write down what you did and why. Future you will thank past you.
Community Engagement: The Nagios community is vast and knowledgeable. Don't be shy; ask for help or share your experiences.

Wrapping Up

Congratulations! You've taken your first steps into the world of Nagios monitoring. Remember, the path to mastering Nagios is paved with trial, error, and a lot of Googling. But with patience and practice, you'll soon wield the power of Nagios like a DevOps wizard.

Stay curious, and happy monitoring!

Getting Started with Ansible: A Practical Guide for DevOps Newcomers

Scott Gordon — Sat, 17 Feb 2024 04:57:43 +0000

Introduction

DevOps emphasizes automation to make infrastructure management more efficient and consistent. Ansible is a super-star in the automation realm, known for its simplicity and effectiveness. In this tutorial, we'll dive into the fundamentals of Ansible and walk through a practical demonstration.

Prerequisites

A basic grasp of Linux/Unix command-line environments.
A control machine (your laptop/desktop) with Python installed.
One or more remote Linux servers you can SSH into.

Benefits of Ansible

Agentless: No need to install software on your managed servers.
Simple Syntax: Human-readable YAML playbooks define your tasks.
Idempotent: Tasks can be run repeatedly, desiring the same end state.
Extensible: Hundreds of built-in modules to interact with common systems.

Use Cases

Configuration Management: Keep servers in a consistent, defined state.
Software Deployment: Install and update applications across many servers.
Orchestration: Automate complex tasks spanning multiple systems.
Server Provisioning: Set up new servers quickly and consistently.

Tutorial

Install Ansible (Control Machine)

pip install ansible

Create an Inventory File called hosts in your working directory
(hosts)

[webservers]
<SERVER1_IP_ADDRESS_GOES_HERE>
<SERVER2_IP_ADDRESS_GOES_HERE>

Test Connectivity

ansible all -m ping

Make sure you have SSH access to remote servers (using keys or password).

Create Your First Playbook
(demo.yml)

---
- hosts: webservers
  become: true  # Use sudo privileges if needed
  tasks:
    - name: Install Apache Web Server
      apt:
        name: apache2
        state: latest
    - name: Ensure Apache is running
      service:
        name: apache2
        state: started

Run the Playbook

ansible-playbook demo.yml -i hosts

Double check that Apache is running on each server by SSHing into each and running

sudo systemctl status apache2

Explanation

Playbooks are YAML files expressing your configuration "plays".
hosts targets groups of servers from your inventory.
become provides superuser privileges for commands if necessary.
tasks are individual units of work (uses Ansible modules).
modules (like apt and service) manage packages, services, files, etc. Next Steps

Explore more Ansible modules: Modules
Learn about variables and templates for dynamic configuration. Templating
Dive into Ansible roles for organizing complex playbooks. Roles

Takedown Instructions

To reverse the changes made during this tutorial, consider these steps:

1. Undoing Package Installations

If you installed packages using Ansible's apt (Debian/Ubuntu) or yum (RedHat/CentOS) modules, use the following commands to remove them:

ansible-playbook -i hosts rollback.yml

Create a rollback.yml file:

---
- hosts: webservers 
  become: true
  tasks:
    - name: Remove Apache Web Server
      apt:
        name: apache2
        state: absent

(Customize based on installed packages)

2. Stopping Services

If you started services:

- name: Ensure Apache is stopped
  service:
    name: apache2
    state: stopped

3. Reverting Configuration Files

If you modified configuration files, it's best to:
- Restore from backups if you created them before applying Ansible changes.
- Manually edit the files to revert changes (this requires specific knowledge of your configurations).

Important Notes

Carefully review the original playbook to identify all the actions performed.
Create Ansible tasks tailored to reverse these actions when possible.
Always test takedown procedures in a non-production environment first!

Photo by Growtika on Unsplash

GAN Image Generator

Scott Gordon — Fri, 19 Jan 2024 22:03:23 +0000

Github Repo

"""
This module contains the implementation of a Generative Adversarial Network 
(GAN) using TensorFlow and Keras.

The GAN is composed of a generator and a discriminator, both implemented as 
Keras models. The generator takes a random noise vector as input and produces 
an image, while the discriminator takes an image as input and classifies it 
as real or fake.

The module provides functions to build the generator, the discriminator, and 
the complete GAN, as well as to train the GAN on the MNIST dataset and 
generate and save images.

Functions:
    build_generator(latent_dim: int) -> models.Model
    build_discriminator(img_shape: tuple) -> models.Model
    build_gan(generator: models.Model, discriminator: models.Model) -> models.
        Model
    train_gan(generator: models.Model, discriminator: models.Model, 
        gan: models.Model, mnist_data: np.array, latent_dim: int, 
        epochs: int, batch_size: int, sample_interval: int)
    generate_and_save_images(generator: models.Model, epoch: int, 
        test_input: np.array)
"""

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models


def build_generator(latent_dim):
    """
    Build the generator part of the GAN.

    Args:
        latent_dim (int): The size of the random noise vector used as input 
        for the generator.

    Returns:
        model: A Keras model representing the generator.
    """
    model = models.Sequential()
    model.add(layers.Dense(7 * 7 * 128, input_dim=latent_dim))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Reshape((7, 7, 128)))

    model.add(layers.Conv2DTranspose(
        128, (4, 4), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU(alpha=0.2))

    model.add(layers.Conv2DTranspose(
        128, (4, 4), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU(alpha=0.2))

    model.add(layers.Conv2D(1, (7, 7), activation='tanh', padding='same'))
    return model


def build_discriminator(img_shape):
    """
    Build the discriminator part of the GAN.

    Args:
        img_shape (tuple): The shape of the input images.

    Returns:
        model: A Keras model representing the discriminator.
    """
    model = models.Sequential()
    model.add(layers.Conv2D(64, (3, 3), strides=(2, 2),
              padding='same', input_shape=img_shape))
    model.add(layers.LeakyReLU(alpha=0.2))

    model.add(layers.Conv2D(128, (3, 3), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU(alpha=0.2))

    model.add(layers.Flatten())
    model.add(layers.Dense(1, activation='sigmoid'))
    return model


def build_gan(generator, discriminator):
    """
    Build the complete GAN by stacking the generator and discriminator.

    Args:
        generator (Keras model): The generator model.
        discriminator (Keras model): The discriminator model.

    Returns:
        model: A Keras model representing the complete GAN.
    """
    discriminator.trainable = False
    model = models.Sequential()
    model.add(generator)
    model.add(discriminator)
    return model


def load_mnist():
    """
    Load and preprocess the MNIST dataset.

    Returns:
        X_train (numpy array): The preprocessed training images.
    """
    (X_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
    X_train = (X_train.astype(np.float32) - 127.5) / 127.5
    X_train = np.expand_dims(X_train, axis=-1)
    return X_train


def train_gan(generator, discriminator, gan, mnist_data, latent_dim, 
              epochs=10000, batch_size=128, sample_interval=1000):
    """
    Train the GAN on the MNIST data.

    Args:
        generator (Keras model): The generator model.
        discriminator (Keras model): The discriminator model.
        gan (Keras model): The complete GAN model.
        mnist_data (numpy array): The preprocessed training images.
        latent_dim (int): The size of the random noise vector used as input 
        for the generator.
        epochs (int, optional): The number of epochs to train for. Defaults 
        to 10000.
        batch_size (int, optional): The batch size. Defaults to 128.
        sample_interval (int, optional): The interval at which to save 
        generated images. Defaults to 1000.
    """
    half_batch = batch_size // 2

    for epoch in range(epochs):
        # Train Discriminator
        idx = np.random.randint(0, mnist_data.shape[0], half_batch)
        imgs = mnist_data[idx]
        noise = np.random.normal(0, 1, (half_batch, latent_dim))
        gen_imgs = generator.predict(noise)

        d_loss_real = discriminator.train_on_batch(
            imgs, np.ones((half_batch, 1)))
        d_loss_fake = discriminator.train_on_batch(
            gen_imgs, np.zeros((half_batch, 1)))
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

        # Train Generator
        noise = np.random.normal(0, 1, (batch_size, latent_dim))
        valid_labels = np.ones((batch_size, 1))
        g_loss = gan.train_on_batch(noise, valid_labels)

        # Print progress and save generated images at specified intervals
        if epoch % sample_interval == 0:
            print(f"Epoch {epoch}, D Loss: {d_loss[0]}, G Loss: {g_loss}")
            save_generated_images(epoch, generator)


def generate_and_save_images(generator, epoch, test_input):
    """
    Generate and save images using the generator and display them using matplotlib.

    Args:
        generator (Keras model): The generator model.
        epoch (int): The current epoch.
        test_input (numpy array): A random noise vector used as input for the 
        generator.
    """
    predictions = generator(test_input, training=False)
    fig = plt.figure(figsize=(4, 4))

    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i + 1)
        plt.imshow(predictions[i, :, :, 0] * 0.5 + 0.5, cmap='gray')
        plt.axis('off')

    plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
    plt.show()

def save_generated_images(epoch, generator, latent_dim=100, examples=100, dim=(10, 10), figsize=(10, 10)):
    """
    Save the images generated by the generator.

    Args:
        epoch (int): The current epoch.
        generator (Keras model): The generator model.
        latent_dim (int, optional): The size of the random noise vector used as input for the generator. Defaults to 100.
        examples (int, optional): The number of examples to generate. Defaults to 100.
        dim (tuple, optional): The dimensions of the grid of images. Defaults to (10, 10).
        figsize (tuple, optional): The size of the figure. Defaults to (10, 10).
    """
    noise = np.random.normal(0, 1, size=[examples, latent_dim])
    generated_images = generator.predict(noise)
    generated_images = generated_images.reshape(examples, 28, 28)

    plt.figure(figsize=figsize)
    for i in range(generated_images.shape[0]):
        plt.subplot(dim[0], dim[1], i+1)
        plt.imshow(generated_images[i], interpolation='nearest', cmap='gray_r')
        plt.axis('off')
    plt.tight_layout()
    plt.savefig(f'gan_generated_image_epoch_{epoch}.png')


if __name__ == "__main__":
    # Define the size of the random vector used as input for the generator
    latent_dim = 100

    # Build the generator
    generator = build_generator(latent_dim)

    # Build the discriminator
    img_shape = (28, 28, 1)

Photo by Steve Johnson on Unsplash

Client / Server Chat

Scott Gordon — Fri, 26 Nov 2021 18:50:14 +0000

Github Repo

# client_server_chat
#   This is a program to demonstate a chat between client and server using UDP.
#   Run this program and add either client or server as an argument.
#   Once you have run both client and server you can chat between them.
# by Scott Gordon with help from Educative.com

import argparse, socket

MAX_SIZE_BYTES = 65535  # Mazimum size of a UDP datagram


def server(port):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    hostname = "127.0.0.1"
    s.bind((hostname, port))
    print("Listening at {}".format(s.getsockname()))
    while True:
        data, clientAddress = s.recvfrom(MAX_SIZE_BYTES)
        message = data.decode("ascii")
        print("The client at {} says {!r}".format(clientAddress, message))
        msg_to_send = input("Input message to send to client:")
        data = msg_to_send.encode("ascii")
        s.sendto(data, clientAddress)


def client(port):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    host = "127.0.0.1"
    while True:
        s.connect((host, port))
        message = input("Input message to send to server:")
        data = message.encode("ascii")
        s.send(data)
        data = s.recv(MAX_SIZE_BYTES)
        text = data.decode("ascii")
        print("The server replied with {!r}".format(text))


if __name__ == "__main__":
    funcs = {"client": client, "server": server}
    parser = argparse.ArgumentParser(description="UDP client and server")
    parser.add_argument("functions", choices=funcs, help="client or server")
    parser.add_argument(
        "-p", metavar="PORT", type=int, default=3000, help="UDP port (default 3000)"
    )
    args = parser.parse_args()
    function = funcs[args.functions]
    function(args.p)

Verify my Python

Photo by Kelvin Ang on Unsplash

Rock, Paper, Scissors, Lizard, Spock

Scott Gordon — Wed, 17 Nov 2021 21:15:45 +0000

GitHub Repo

/*
    This program emulates the version of rock, paper, scissors popularized 
    by the tv series "Big Bang Theory". This variety utilizes the typical 
    rock, paper and scissors paradigm while adding lizard and spock to the
    equation. (scissors > paper > rock > lizard > spock > scissors > lizard >
    paper > spock > rock > scissors)
*/
#include <iostream>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    srand(time(NULL));

    int user = -1;

    std::cout << "=================================\n";
    std::cout << "Rock, Paper, Scissors Lizard Spock!\n";
    std::cout << "=================================\n";

    while (user != 0)

    {
        std::cout << "1)👊 2)✋ 3)✌️ 4)🦎 5)🖖 0)🛑\n";
        std::cout << "\n";
        std::cout << "Shoot!\n";
        std::cin >> user;
        std::cout << "\n";
        int computer = rand() % 5 + 1;

        if (user == computer)
        {
            std::cout << "It's a tie, try again please.\n";
            std::cout << "\n";
        }
        else if ((user == 1) && (computer == 2))
        {
            std::cout << "You: 👊 Computer: ✋\n";
            std::cout << "Computer wins, Paper covers Rock.\n";
            std::cout << "\n";
        }
        else if ((user == 1) && (computer == 3))
        {
            std::cout << "You: 👊 Computer: ✌️\n";
            std::cout << "You win, Rock crushes Scissors.\n";
            std::cout << "\n";
        }
        else if ((user == 1) && (computer == 4))
        {
            std::cout << "You: 👊 Computer: 🦎\n";
            std::cout << "You win, Rock crushes Lizard.\n";
            std::cout << "\n";
        }
        else if ((user == 1) && (computer == 5))
        {
            std::cout << "You: 👊 Computer: ️🖖\n";
            std::cout << "Computer wins, Spock vaporizes Rock.\n";
            std::cout << "\n";
        }
        else if ((user == 2) && (computer == 1))
        {
            std::cout << "You: ✋ Computer: ️👊\n";
            std::cout << "You win, Paper covers Rock.\n";
            std::cout << "\n";
        }
        else if ((user == 2) && (computer == 3))
        {
            std::cout << "You: ✋ Computer: ️✌️\n";
            std::cout << "Computer wins, Scissors cuts Paper.\n";
            std::cout << "\n";
        }
        else if ((user == 2) && (computer == 4))
        {
            std::cout << "You: ✋ Computer: ️🦎\n";
            std::cout << "You lose, Lizard eats Paper.\n";
            std::cout << "\n";
        }
        else if ((user == 2) && (computer == 5))
        {
            std::cout << "You: ✋ Computer: ️🖖\n";
            std::cout << "You win, Paper disproves Spock.\n";
            std::cout << "\n";
        }
        else if ((user == 3) && (computer == 1))
        {
            std::cout << "You: ✌️ Computer: ️👊\n";
            std::cout << "Computer wins, Rock crushes Scissors.\n";
            std::cout << "\n";
        }
        else if ((user == 3) && (computer == 2))
        {
            std::cout << "You: ✌️ Computer: ️✋\n";
            std::cout << "You win, Scissors cuts Paper.\n";
            std::cout << "\n";
        }
        else if ((user == 3) && (computer == 4))
        {
            std::cout << "You: ✌️ Computer: ️🦎\n";
            std::cout << "You win, Scissors decapitate Lizard.\n";
            std::cout << "\n";
        }
        else if ((user == 3) && (computer == 5))
        {
            std::cout << "You: ✌️ Computer: ️🖖\n";
            std::cout << "You lose, Spock smashes Scissors.\n";
            std::cout << "\n";
        }
        else if ((user == 4) && (computer == 1))
        {
            std::cout << "You: 🦎 Computer: ️👊\n";
            std::cout << "You lose, Rock crushes Lizard.\n";
            std::cout << "\n";
        }
        else if ((user == 4) && (computer == 2))
        {
            std::cout << "You: 🦎 Computer: ️✋\n";
            std::cout << "You win, Lizard eats paper.\n";
            std::cout << "\n";
        }
        else if ((user == 4) && (computer == 3))
        {
            std::cout << "You: 🦎 Computer: ️✌️\n";
            std::cout << "You lose, Scissors decapitate Lizard.\n";
            std::cout << "\n";
        }
        else if ((user == 4) && (computer == 5))
        {
            std::cout << "You: 🦎 Computer: ️🖖\n";
            std::cout << "You win, Lizard poisons Spock.\n";
            std::cout << "\n";
        }
        else if ((user == 5) && (computer == 1))
        {
            std::cout << "You: 🖖 Computer: ️👊\n";
            std::cout << "You win, Spock vaporizes Rock.\n";
            std::cout << "\n";
        }
        else if ((user == 5) && (computer == 2))
        {
            std::cout << "You: 🖖 Computer: ️✋\n";
            std::cout << "Computer wins, Paper disproves Spock.\n";
            std::cout << "\n";
        }
        else if ((user == 5) && (computer == 3))
        {
            std::cout << "You: 🖖 Computer: ️✌️\n";
            std::cout << "You win, Spock smashes scissors.\n";
            std::cout << "\n";
        }
        else if ((user == 5) && (computer == 4))
        {
            std::cout << "You: 🖖 Computer: ️🦎\n";
            std::cout << "You lose, Lizard poisons Spock.\n";
            std::cout << "\n";
        }
        else
        {
            std::cout << "Please enter a valid number.\n";
            std::cout << "\n";
        }
    }

    return 0;
}

Verify my C++

Photo by Marcus Wallis on Unsplash

Piggy Bank

Scott Gordon — Wed, 17 Nov 2021 04:03:33 +0000

GitHub Repo

#include <iostream>

int main(int argc, char const *argv[])
{
    double pesos = 0, reais = 0, soles = 0;
    const double pesos_usd = 0.048, reais_usd = 0.18, soles_usd = 0.25;

    std::cout << "Enter number of Colombian Pesos: ";
    std::cin >> pesos;

    std::cout << "Enter number of Brazillian Reais: ";
    std::cin >> reais;

    std::cout << "Enter number of Peruvian Soles: ";
    std::cin >> soles;

    double total_amount = (pesos * pesos_usd) + (reais * reais_usd) + (soles * soles_usd);
    std::cout << "US Dollars = $" << total_amount << "\n";

    return 0;
}

Verify my C++

Photo by Jason Leung on Unsplash

React Tic Tac Toe

Scott Gordon — Sat, 13 Nov 2021 22:10:16 +0000

GitHub Repo

// index.js
import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';

function Square(props) {
  return (
    <button className="square" onClick={props.onClick}>
      {props.value}
    </button>
  );
}


class Board extends React.Component {
  renderSquare(i) {
    return (
      <Square
        value={this.props.squares[i]}
        onClick={() => this.props.onClick(i)}
      />
    );
  }

  render() {
    return (
      <div>
        <div className="board-row">
          {this.renderSquare(0)}{this.renderSquare(1)}{this.renderSquare(2)}
        </div>
        <div className="board-row">
          {this.renderSquare(3)}{this.renderSquare(4)}{this.renderSquare(5)}
        </div>
        <div className="board-row">
          {this.renderSquare(6)}{this.renderSquare(7)}{this.renderSquare(8)}
        </div>
      </div>
    );
  }
}

class Game extends React.Component {
  constructor(props) {
    super(props);
    this.state = {
      history: [{
        squares: Array(9).fill(null),
      }],
      stepNumber: 0,
      xIsNext: true,
    };
  }

  handleClick(i) {
    const history = this.state.history.slice(0, this.state.stepNumber + 1);
    const current = history[history.length - 1];
    const squares = current.squares.slice();
    if (calculateWinner(squares) || squares[i]) {
      return;
    }
    squares[i] = this.state.xIsNext ? 'X' : 'O';
    this.setState({
      history: history.concat([{
        squares: squares,
      }]),
      stepNumber: history.length,
      xIsNext: !this.state.xIsNext,
    });
  }

  jumpTo(step) {
    this.setState({
      stepNumber: step,
      xIsNext: (step % 2) === 0,
    });
  }

  render() {
    const history = this.state.history;
    const current = history[this.state.stepNumber];
    const winner = calculateWinner(current.squares);

    const moves = history.map((step, move) => {
      const desc = move ?
        'Go to move #' + move :
        'Go to game start';
      return (
        <li key={move}>
          <button onClick={() => this.jumpTo(move)}>
            {desc}
          </button>
        </li>
      );
    });

    let status;
    if (winner) {
      status = 'Winner: ' + winner;
    } else {
      status = 'Next player: ' + (this.state.xIsNext ? 'X' : 'O');
    }

    return (
      <div className="game">
        <div className="game-board">
          <Board
            squares={current.squares}
            onClick={(i) => this.handleClick(i)}
          />
        </div>
        <div className="game-info">
          <div>{status}</div>
          <ol>{moves}</ol>
        </div>
      </div>
    );
  }
}

// ========================================

ReactDOM.render(
  <Game />,
  document.getElementById('root')
);

function calculateWinner(squares) {
  const lines = [
    [0, 1, 2],
    [3, 4, 5],
    [6, 7, 8],
    [0, 3, 6],
    [1, 4, 7],
    [2, 5, 8],
    [0, 4, 8],
    [2, 4, 6],
  ];
  for (let i = 0; i < lines.length; i++) {
    const [a, b, c] = lines[i];
    if (squares[a] && squares[a] === squares[b] && squares[a] === squares[c]) {
      return squares[a]
    }
  }
  return null;
}

/* index.css */
body {
    font: 14px "Century Gothic", Futura, sans-serif;
    margin: 20px;
  }

  ol, ul {
    padding-left: 30px;
  }

  .board-row:after {
    clear: both;
    content: "";
    display: table;
  }

  .status {
    margin-bottom: 10px;
  }

  .square {
    background: #fff;
    border: 1px solid #999;
    float: left;
    font-size: 24px;
    font-weight: bold;
    line-height: 34px;
    height: 34px;
    margin-right: -1px;
    margin-top: -1px;
    padding: 0;
    text-align: center;
    width: 34px;
  }

  .square:focus {
    outline: none;
  }

  .kbd-navigation .square:focus {
    background: #ddd;
  }

  .game {
    display: flex;
    flex-direction: row;
  }

  .game-info {
    margin-left: 20px;
  }

Photo by Matthew Davis on Unsplash

DEV Community: Scott Gordon

Kubernetes Simplified: Embarking on the Zero to Hero Journey - Part 2

Namespaces

Readiness and Liveness Probes

Autoscaling

Resource Requests and Limits

Deploying Your Pods

Multiple Nodes

Role-based Access Control (RBAC)

Hosting Your Kubernetes Cluster Externally

Conclusion

Kubernetes Simplified: Embarking on the Zero to Hero Journey

What is Kubernetes?

Introduction

Containerization and Kubernetes

Kubernetes: The Container Orchestrator

Why Kubernetes?

Further Reading

Mastering Your Digital Toolbox: Setting Up JFrog Artifactory with Terraform

Introduction: The Craft of Infrastructure

Terraform: The Smart Toolbox

Step 1: Crafting Your Workshop Layout

Step 2: Securing Your Workshop

Step 3: Organizing Your Materials (Artifacts)

JFrog Artifactory: The Ultimate Storage Cabinet

Integrating Terraform and Artifactory

Conclusion: A Workshop That Works for You

Building a Cloud Infrastructure with Terraform: A Real-World Guide

Introduction

Prerequisites

Step 1: Laying the Groundwork with Our VPC

Explanation

Step 2: Building the Roads (Subnets)

Explanation

Step 3: Powering Our City (Internet Gateway)

Explanation

Step 4: Constructing Buildings (EC2 Instances)

Explanation

Step 5: Opening Public Spaces (ALB)

Explanation

Wrapping Up

LEGO 3D Coordinates

The Grid Dimensions

The Rule (N)

Visualizing Coordinates

Real-World Example

The List of Allowed Coordinates

Visualization

Here is the code in Python using a list comprehension.

Nagios for DevOps Beginners: A Simple Guide to Effective Monitoring

What is Nagios?

Why Nagios?

Getting Started with Nagios

Step 1: Installation

Step 2: Configuration

Hosts and Services

Step 3: Monitoring

Step 4: Reacting to Alerts

Best Practices

Wrapping Up

Getting Started with Ansible: A Practical Guide for DevOps Newcomers

Introduction

Takedown Instructions

GAN Image Generator

Client / Server Chat

Rock, Paper, Scissors, Lizard, Spock

Piggy Bank

React Tic Tac Toe