In today’s rapidly evolving tech landscape, AI agents are becoming increasingly accessible to developers of all skill levels. This article introduces the concept of AI agents and walks through creating a simple yet practical example: a landing page generator powered by language models running locally on your system using Ollama.

What Are AI Agents?

AI agents are software programs that can perform tasks with varying degrees of autonomy using artificial intelligence techniques. They typically:

1. Take input from users or environment
2. Process information using AI models
3. Perform actions based on this processing
4. Provide output or feedback to users

The complexity of AI agents ranges from simple task-specific tools to sophisticated systems with complex reasoning capabilities.

Prerequisites: Running Local LLMs with Ollama

Before diving into our AI agent, make sure you have Ollama set up on your system. If you haven’t installed it yet, I’ve written a comprehensive guide on how to run local LLMs with Ollama. This will walk you through the installation process and get you ready to build your first AI agent.

Anatomy of a Simple AI Agent

The landing page generator we’re examining represents a basic AI agent with these key components:

1. User Interface

A command-line interface collecting user requirements and displaying results.

2. AI Integration Layer

Code that formats prompts and communicates with the AI model (Ollama’s DeepSeek in this case).

3. Processing Logic

Functions for extracting relevant content from AI responses and saving the output.

4. Action Execution

Code that opens the generated landing page and handles user workflow.

How This Landing Page Generator Works

This agent follows a straightforward workflow:

1. User Input: Collects a description of the desired landing page
2. AI Instruction: Sends carefully crafted prompts to the language model
3. Response Processing: Extracts HTML/CSS code from the model’s response
4. Output Generation: Saves the code as an HTML file
5. Result Delivery: Opens the file in a browser and offers to create another

Key Design Principles

Looking at the code, we can identify several principles for effective AI agent design:

Clear, Specific Prompts

The system prompt defines the agent’s role as a “skilled web developer” and provides specific constraints (using Tailwind CSS, delivering ready-to-use code).

Error Handling

The code gracefully handles potential failures in AI generation, extraction, and file operations.

User Experience Focus

The interface includes progress updates, confirmation prompts, and clear navigation options.

The Landing Page Generator Code

import ollama
import os
import re
from pathlib import Path
from datetime import datetime


def generate_landing_page(description):
    """Use Ollama to generate HTML/CSS for a landing page based on description."""
    messages = [
        {"role": "system",
         "content": "You are a skilled web developer who creates clean, responsive landing pages using HTML, CSS, and minimal JavaScript. Your code should be complete, valid, and ready to use without external dependencies."},
        {"role": "user",
         "content": f"Create a complete landing page based on this description: {description}. Provide only the HTML code with internal CSS and JavaScript. The code should be complete and ready to be saved as an index.html file."}
    ]

    try:
        print("Generating landing page... This may take a minute or two...")
        response = ollama.chat(
            model='deepseek-r1:8b',
            messages=messages
        )

        # Extract HTML code from response
        html_content = response['message']['content']

        # Extract code between ```html and ``` if present
        code_pattern = re.compile(r'```(?:html)?\s*([\s\S]*?)\s*```')
        match = code_pattern.search(html_content)

        if match:
            return match.group(1).strip()
        else:
            # If no code blocks found, try to extract just the HTML
            if "<html" in html_content and "</html>" in html_content:
                start = html_content.find("<html")
                end = html_content.find("</html>") + 7
                return html_content[start:end]
            return html_content

    except Exception as e:
        return f"Error generating landing page: {str(e)}"


def save_landing_page(html_content, output_dir="landing_pages"):
    """Save the generated HTML to a file."""
    # Ensure the output directory exists
    Path(output_dir).mkdir(exist_ok=True)

    # Create a filename with timestamp
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{output_dir}/landing_page_{timestamp}.html"

    # Save the HTML content
    with open(filename, "w", encoding="utf-8") as f:
        f.write(html_content)

    return filename


def main():
    """Run the dedicated landing page generator."""
    print("==========================================")
    print("  LANDING PAGE GENERATOR (OLLAMA)  ")
    print("==========================================")

    # Get description for the landing page
    print("\nDescribe the landing page you want (be specific about colors, layout, features):")
    description = input("> ")

    if not description:
        print("Error: You must provide a description for the landing page.")
        return

    # Generate the landing page HTML
    html_content = generate_landing_page(description)

    # Save the landing page
    filename = save_landing_page(html_content)

    print(f"\nSuccess! Landing page created and saved to: {filename}")

    # Ask if user wants to open the file
    open_file = input("Would you like to open the landing page now? (y/n): ")
    if open_file.lower() in ['y', 'yes']:
        # Try to open the file in the default browser
        try:
            import webbrowser
            file_path = os.path.abspath(filename)
            webbrowser.open('file://' + file_path)
            print(f"Opened {filename} in your default browser.")
        except Exception as e:
            print(f"Couldn't open the file automatically: {e}")
            print(f"Please open {filename} manually in your browser.")

    # Ask if user wants to create another landing page
    another = input("\nWould you like to create another landing page? (y/n): ")
    if another.lower() in ['y', 'yes']:
        main()  # Recursive call
    else:
        print("Thank you for using the Landing Page Generator. Goodbye!")


if __name__ == "__main__":
    main()

I am using deepseek-r1:8b and I have also tried qwen2.5-coder:14b which gave me a better result. Feel free to tweak the script to match your setup.

You can visit my GitHub Repo where I will be adding more examples as I continue my journey in this exciting field of AI.

https://github.com/Ali-Shaikh

Going Beyond: Enhancing Your AI Agents

Again, this is a simple example to help you get up and running with creating an AI Agent. To create more sophisticated AI agents, consider:

• Multiple Model Integration: Combine specialised models for different aspects of a task
• Memory and Context: Maintain conversation history for more coherent interactions
• User Preference Learning: Store and apply user preferences over time
• Feedback Loops: Collect user feedback to improve future outputs
• Validation Layers: Add code to validate AI outputs before presenting them

Conclusion

The landing page generator demonstrates how even simple AI agents can provide significant value. By combining clear prompts, effective processing, and thoughtful user experience design, developers can create tools that leverage AI to solve specific problems.

As you build your own AI agents, remember that the quality of your prompts, the robustness of your error handling, and the thoughtfulness of your user experience will largely determine your success.

In a nutshell, an AI agent is basically like calling an API with parameters, processing the result, manipulating it to your requirements and displaying the output. Anyone can get started with building an AI agent using Ollama or LM Studio. If you have a modest system, try using any of the smaller models such as qwen2.5-coder:3b or even a smaller model such as qwen2.5-coder:1.5b.

Smaller models are a great starting point, and while they may not offer the same quality as larger models, they are perfect for building your skills. As you get more comfortable with creating AI agents, you’ll be ready to work with larger models to unlock even more powerful capabilities!

Keep creating and innovating, and I would love to hear and see what you create. please feel free to share any comments, questions and examples of what you got done in the comments. If you need any help, feel free to reach out through my LinkedIn.

Originally published at https://alishaikh.me on March 4, 2025.

In the world of artificial intelligence (AI) and large language models (LLMs), tokens are the essential building blocks that allow these systems to process and understand text. But what exactly are tokens, and how can a tool like TikTokenizer help us explore them? Let’s dive in.

What Are Tokens?

Tokens are the smallest units of text that an AI language model works with. Depending on the tokenization method, a token could be:

• A word (e.g., “love” or “AI”),
• A subword (e.g., “play” and “##ing” for “playing”),
• Or even an individual character (e.g., “A” or “!”).

For instance, the sentence “I love AI” might be tokenized as [“I”, “love”, “AI”]. Tokenization is the process of breaking down raw text into these units, transforming it into a format that a model can interpret. This step is critical because it determines how the model “sees” the text, influencing its ability to generate responses or understand meaning.

Why Tokenization Matters

Tokenization isn’t just a technical detail — it directly affects a model’s performance. The way text is split into tokens impacts:

• Efficiency: Smaller tokens might mean more processing steps, while larger ones could simplify things.
• Accuracy: Misaligned token boundaries might confuse the model’s interpretation.

Understanding tokenization is key for anyone working with LLMs, whether you’re crafting prompts, debugging outputs, or optimizing text inputs.

Enter TikTokenizer

The TikTokenizer tool is a fantastic resource for visualizing and experimenting with tokenization. It’s interactive and user-friendly: simply type in any text, and the tool breaks it down into tokens, showing each one alongside its unique token ID — a numerical value that models use internally. For example, input “I love AI!” and you’ll see how it’s split and numbered.

How to Use It

1. Visit TikTokenizer.
2. Enter a sentence-like “Hello, world!”-into the text box.
3. Watch as it displays the tokens (e.g., [“Hello”, “,”, “world”, “!”]) and their IDs.

You can play around with it by:

• Adding punctuation (e.g., “Hello,world” vs. “Hello, world”),
• Changing capitalization (e.g., “hello” vs. “HELLO”),
• Or trying complex phrases to see how the tokenization adapts.

This hands-on approach makes it easy to see how different choices affect the process.

Why It’s Useful

TikTokenizer isn’t just a fun toy — it’s a practical tool for anyone interested in AI and LLMs. Here’s why it’s worth exploring:

• Prompt Engineering: Learn to craft prompts that fit within token limits for better results.
• Debugging: Spot why a model might misread your input by checking how it’s tokenized.
• Learning: Gain a clearer grasp of NLP concepts if you’re new to the field.
• Optimization: Tweak your text preprocessing to improve model performance.

Wrap-Up

Alright, let’s wrap this up! Tokens are the core of how AI language models make sense of text, and TikTokenizer lets you peek under the hood. Type something in, and it breaks it down into tokens with their IDs--super straightforward and honestly kinda cool. It’s perfect whether you’re new to AI or a seasoned pro. Want to see how your words get “read” by a machine? Check out TikTokenizer and give it a spin!

Originally published at https://alishaikh.me on March 1, 2025.

SSH (Secure Shell) is a common way to securely connect to remote Linux machines. Instead of using passwords, SSH keys make logging in safer and easier. This guide will show you how to install an SSH server, create SSH keys, add your public key to the remote server and then connect using your SSH keys.

1. Installing the SSH Server

To enable SSH access, the remote Linux machine must have an SSH server installed.

For Debian-based Systems (e.g., Ubuntu)

sudo apt update
sudo apt install openssh-server -y
sudo systemctl enable ssh
sudo systemctl start ssh

For Red Hat-based Systems (e.g., CentOS, Rocky Linux)

sudo yum update -y
sudo yum install -y openssh-server
sudo systemctl enable sshd
sudo systemctl start sshd

Verify SSH Server is Running

sudo systemctl status ssh  # For Ubuntu/Debian
sudo systemctl status sshd # For CentOS/RHEL

If the server is running you should see active (running) as shown below.

2. Generating SSH Keys on your Local Machine

SSH keys consist of a private key (kept secure on your local machine) and a public key (placed on the remote server). If you haven’t generated SSH keys before, check out this detailed guide:

🔗 Generating SSH Keys on Windows, Linux, and macOS

Once you’ve generated your SSH keys, proceed to the next step to configure the server for SSH key-based authentication by adding your public key to the remote server.

3. Adding your Public Key to the Remote Machine

Now, we need to copy the public key to the remote server so it can allow your key to be used to log in.

Copy your Public Key from the Local Machine

On your local machine, display the public key by running cat ~/.ssh/id_rsa.pub or opening the .pub file in Notepad, and copy the contents.

Prepare the Remote Server

On the remote machine, create the .ssh directory and authorized_keys file if they do not already exist.

mkdir -p ~/.ssh
touch ~/.ssh/authorized_keys

Add the Public Key to Authorized Keys

Paste the copied key into the ~/.ssh/authorized_keys file on the remote machine. If there's already another key in the file, make sure to add your key on a new line.

Alternatively, you can use echo command on the remote machine and append it directly:

echo "PASTE_PUBLIC_KEY_HERE" >> ~/.ssh/authorized_keys

Set the correct permissions to ensure security:

Some systems will now allow you to use your SSH keys if the permissions are too open or incorrect. Run the following commands to set the recommended permissions.

chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

4. Connecting to the Remote Machine Using SSH Keys

Now that the remote machine is ready for SSH-based authentication and your public key has successfully been added, you can connect from your local machine:

ssh username@remote_host

If your private key exists in a non-default location, then provide the path to the private key by using the following command:

ssh -i /path/to/private_key username@remote_host

Conclusion

You have now set up your remote server for SSH access and learned how to log in securely using SSH keys, eliminating the need to enter a password each time. This method enhances security and convenience, making remote access more efficient. With SSH keys in place, you can now connect to your server seamlessly and focus on what matters most.

In the previous guide, we learnt how to generate SSH Keys on Windows, Linux, and macOS, read here.

In this guide, we’ll explain how to use your SSH keys to clone GitHub repositories — a common task for developers working on projects locally. And remember, these SSH keys aren’t just for cloning; they also secure your push and pull operations.

Prerequisites

Before you begin, make sure:

• SSH Key Pair: You have generated an SSH key pair, to learn how click here.
• Git Installed: Git is installed on your system.
• Internet Access: You can access GitHub.

Adding Your SSH Key to GitHub

Step 1: Copy Your Public Key

Your public key is typically stored in a file like ~/.ssh/id_ed25519.pub (or id_rsa.pub if you’re using RSA). You can simply display the key and copy it.

cat ~/.ssh/id_rsa.pub

OR

cat ~/.ssh/id_ed25519.pub

Step 2: Log in to Your GitHub Account

Open your web browser and navigate to GitHub.com. Log in with your credentials.

Step 3: Navigate to SSH Keys Settings

Click your profile icon in the top right corner and select ‘Settings.’

In the left sidebar, click ‘SSH and GPG keys.’

Step 4: Add a New SSH Key

Click on the “New SSH key” button.

Title: Enter a descriptive title (e.g., ‘My Laptop Key’).

Key: Paste the copied public key into the key field.

Click “Add SSH key.”

Cloning a Repository Using SSH

Now you are ready to enter the realm of passwordless authentication!

Step 1: Verify Your SSH Connection

Before cloning, verify that your SSH configuration is working:

ssh -T git@github.com

If it’s your first time connecting, you might be asked to confirm the authenticity of GitHub’s host. Type ‘yes’ to continue.

If all goes well then you will see the following success message.

This means you are now good to go and use SSH to Clone GitHub repositories.

Step 2: Obtain the Repository’s SSH URL

1. Navigate to your repository on GitHub.
2. Click the ‘Code’ button.
3. Select the ‘SSH’ tab and copy the URL

Step 3: Clone the Repository

In your terminal, change to the directory where you want the repository and type ‘git clone’ followed by the ‘SSH repository URL’ you copied earlier and hit enter.

Aaaand that's it! You have successfully learnt how to clone GitHub repositories without having to enter your username and password.

Conclusion

By following these steps, you’ve not only added your SSH key to GitHub but also learned how to clone repositories securely over SSH.

This method works seamlessly for all Git operations, including pushing new commits and pulling updates from remote repositories. You can follow the same steps to add your SSH keys in GitLab, BitBucket, and more.

This is a very convenient way of accessing Git repositories and will make your development workflows more efficient.

Happy coding!

In a future tutorial, we will learn how to SSH into a remote server.

Recently I embarked on a journey to set up Kubernetes Cluster on my home lab running Proxmox. From my experience designing K8s architectures on AWS EKS and Azure AKS, I knew I would need to create multiple VMs so instead of having to create them 1 by 1 and repeating the same steps I decided to leverage automation and Cloud‑Init enabled VM templates to streamline the process.

How Cloud‑Init and Proxmox Automation Help

Cloud‑Init is a powerful tool designed for early initialisation of cloud instances. By leveraging Cloud‑Init with Proxmox, you can automate the initial configuration of your VMs, installing necessary packages, setting up SSH keys, and even pre-configuring network settings. Once the VM template is created, deploying new VMs becomes a matter of minutes rather than hours, ensuring that each instance is consistently configured and ready to run immediately.

More Automation Queue in Bash — Scripting 😍

Below is the Bash script that automates the entire process, streamlining the configuration and setup of your VM template. Why Type When You Can Script, Eh? 😏

#!/bin/bash

# VM and storage identifiers
VMID=10002
STORAGE=local-lvm

# Define the VM name and Ubuntu image parameters
VM_NAME="ubuntu-2404-cloudinit-template"
STORAGE="local-lvm"  # Adjust if using a different storage backend
IMAGE_URL="https://cloud-images.ubuntu.com/daily/server/releases/24.04/release/ubuntu-24.04-server-cloudimg-amd64.img"
IMAGE_PATH="/var/lib/vz/template/iso/$(basename ${IMAGE_URL})"

# Cloud‑Init credentials (consider stronger hashing for production)
CI_USER="ubuntu"
CI_PASSWORD="$(openssl passwd -6 ubuntu)"

# Create an SSH public key file for injecting into the VM
echo "ssh-rsa PASTE YOUR PUBLIC KEY HERE" > ssh.pub

# 1. Download the Ubuntu 24.04 Cloud Image if not already present
if [ ! -f "${IMAGE_PATH}" ]; then
  echo "Downloading Ubuntu 24.04 Cloud Image..."
  wget -P /var/lib/vz/template/iso/ "${IMAGE_URL}"
else
  echo "Image already exists at ${IMAGE_PATH}"
fi

set -x  # Enable command echoing for debugging

# Destroy any existing VM with the same VMID to avoid conflicts
qm destroy $VMID 2>/dev/null || true

# Create a new VM with UEFI support and custom hardware configurations
echo "Creating VM ${VM_NAME} with VMID ${VMID}..."
qm create ${VMID} \
  --name "${VM_NAME}" \
  --ostype l26 \
  --memory 2048 \
  --cores 2 \
  --agent 1 \
  --bios ovmf --machine q35 --efidisk0 ${STORAGE}:0,pre-enrolled-keys=0 \
  --cpu host --socket 1 --cores 2 \
  --vga serial0 --serial0 socket \
  --net0 virtio,bridge=vmbr0

# Import the downloaded disk image into Proxmox storage
echo "Importing disk image..."
qm importdisk ${VMID} "${IMAGE_PATH}" ${STORAGE}

# Attach the imported disk as a VirtIO disk using the SCSI controller
qm set $VMID --scsihw virtio-scsi-pci --virtio0 $STORAGE:vm-${VMID}-disk-1,discard=on

# Resize the disk by adding an additional 8G
qm resize ${VMID} virtio0 +8G

# Configure the VM to boot from the VirtIO disk
qm set $VMID --boot order=virtio0

# Attach a Cloud‑Init drive (recommended on UEFI systems using SCSI)
qm set $VMID --scsi1 $STORAGE:cloudinit

# Create a custom Cloud‑Init configuration snippet
cat << EOF | tee /var/lib/vz/snippets/ubuntu.yaml
#cloud-config
runcmd:
    - apt-get update
    - apt-get install -y qemu-guest-agent htop
    - systemctl enable ssh
    - reboot
EOF

# Apply Cloud‑Init customizations and additional VM settings
qm set $VMID --cicustom "vendor=local:snippets/ubuntu.yaml"
qm set $VMID --tags ubuntu-template,noble,cloudinit
qm set ${VMID} --ciuser ${CI_USER} --cipassword "${CI_PASSWORD}"
qm set $VMID --sshkeys ~/ssh.pub
qm set $VMID --ipconfig0 ip=dhcp

# Finally, convert the configured VM into a template for rapid future deployment
echo "Converting VM to template..."
qm template ${VMID}

echo "Template ${VM_NAME} (VMID: ${VMID}) created successfully."

Make It Your Own

Before you run the script there are some things you would need to modify to tailor it to your environment. Here’s a quick rundown of the main components you might consider editing:

# VM and storage identifiers
VMID=10002
STORAGE=local-lvm

# Define the VM name and Ubuntu image parameters
VM_NAME="ubuntu-2404-cloudinit-template"
STORAGE="local-lvm"  # Adjust if using a different storage backend
IMAGE_URL="https://cloud-images.ubuntu.com/daily/server/releases/24.04/release/ubuntu-24.04-server-cloudimg-amd64.img"
IMAGE_PATH="/var/lib/vz/template/iso/$(basename ${IMAGE_URL})"

# Cloud‑Init credentials (consider stronger hashing for production)
CI_USER="ubuntu"
CI_PASSWORD="$(openssl passwd -6 ubuntu)"

# Create an SSH public key file for injecting into the VM
echo "ssh-rsa PASTE YOUR PUBLIC KEY HERE" > ssh.pub

• VM Identification & Naming:
  Customize the VMID and VM_NAME to assign a unique identifier and a descriptive name for your template.
• Storage Settings:
  The STORAGE variable lets you define the backend storage (e.g., local-lvm, local-zfs). Adjust this parameter based on your storage setup.
• Image Source & Path:
  The IMAGE_URL points to the cloud image you wish to use, while IMAGE_PATH determines where the image will be stored locally.
• Cloud‑Init Credentials:
  Parameters like CI_USER and CI_PASSWORD are set to pre-configure the default login credentials. Please modify these as per your requirements.
• SSH Key Injection:
  The script injects an SSH public key file for secure access to your VM, saving you the hassle of manually copying SSH keys after deployment. Please add your SSH key here echo "ssh-rsa PASTE YOUR PUBLIC KEY HERE" > ssh.pub. If you need to create a new SSH Key click here to learn how.

How to Use This Script

It’s really simple — just SSH into your Proxmox server, create a new file (e.g., create-ubuntu-2404-template.sh), paste the script into it, make it executable, and run it. The script handles everything for you, from downloading the Ubuntu image to converting the VM into a reusable template.

Here’s a step-by-step guide:

1. SSH into Your Proxmox Server:
   ssh your_user@proxmox-server-ip
2. Create the Script File:
   Use your preferred text editor to create a new file. For example, using Nano: nano create-ubuntu-2404-template.sh
3. Paste the script into this file, then save and exit the editor.
   In Nano, press Ctrl+O to save, then Ctrl+X to exit.
4. Make the Script Executable:
   Change the file permissions to make it executable:
   chmod +x create-ubuntu-2404-template.sh
5. Run the Script:
   Execute the script with:
   ./create

That’s it! With these commands, your Proxmox server will automatically handle downloading the Ubuntu image, setting up the VM, integrating Cloud‑Init, and converting the VM into a reusable template.

Profit!

Awesome! So now you have a shiny template ready to be used. You can use this template to create as many VMs as you want and you will have a brand new VM up and running in minutes. Now let's see how to use this template to create a new VM.

Login to Proxmox and locate the template that you just created

In this example, I will use the ‘ubuntu-2404-cloudinit-k8s-template’. Right-click on the template and click Clone. Fill in the VM ID and Name and click Clone.

Once the cloning is complete, the new VM will appear in your list. You can modify the hardware settings if required, then click Start. The VM will boot up, and Cloud‑Init will automatically perform the initial configuration tasks.

And voila, the VM is created.

In a future tutorial, we will look at how to configure the Cloud-Init configuration to set things like a new user, password, static IP etc. and also I will teach you how to create a Kubernetes-ready template so you can quickly set up as many nodes as you wish.

Feel free to leave any feedback, suggestions or your thoughts down in the comments.

Thank you!

SSH keys are a secure way to authenticate when connecting to remote servers and services such as GitHub Repositories. In this article, we’ll walk through the process of generating SSH keys on three popular operating systems: Windows, Linux, and macOS.

Why Use SSH Keys?

Using SSH keys enhances security by replacing less secure password authentication. Keys are generated as a pair: a public key (which you share with remote servers) and a private key (which you keep secret). Once set up, you can log into your servers or repositories with ease.

Generating SSH Keys on Windows

Using Git Bash

1. Install Git for Windows:
   Download and install Git for Windows, which includes Git Bash — a command-line environment that supports SSH.
2. Open Git Bash:
   Launch Git Bash from the Start menu.
3. Generate the Key Pair:
   Run the following command, replacing 'email@cool-domain.com' with your email address:
   ssh-keygen -t rsa -b 4096 -C 'email@cool-domain.com'
   -t rsa: Specifies the type of key to create.
   -b 4096: Sets the key size to 4096 bits for enhanced security.
   -C 'email@cool-domain.com': Adds a comment to help identify the key. This can be your email address, computer or device name or anything that lets you know what this key is for
4. Follow the Prompts:
   Press Enter to accept the default file location (typically C:\Users\{USERNAME}\.ssh\id_rsa). Choose a secure passphrase when prompted or press enter again to continue without a passphrase.
5. Complete the Process:
   After confirmation, your SSH key pair is created and stored in your user’s .ssh directory. Your public key will have a .pub extension. You can view the public key by running cat ~/.ssh/id_rsa.pub.

Generating SSH Keys on Linux

Using the Terminal

1. Open a Terminal Window:
   Most Linux distributions include a built-in terminal.
2. Generate the Key Pair:
   Enter the following command:
   ssh-keygen -t rsa -b 4096 -C 'email@cool-domain.com'
   command options are identical to those used in Windows.
3. Respond to Prompts:
   Press Enter to accept the default file location (typically ~/.ssh/id_rsa). Choose a secure passphrase when prompted or press enter again to continue without a passphrase.
4. Locate Your Keys:
   Your new SSH key pair will be stored in the ~/.ssh/ directory. You can view the public key using:
   cat ~/.ssh/id_rsa.pub

Generating SSH Keys on macOS

Using the Terminal

1. Open Terminal:
   Find Terminal in your Applications > Utilities folder, or use Spotlight to search for it.
2. Generate the Key Pair:
   Run the following command in the terminal:
   ssh-keygen -t rsa -b 4096 -C 'email@cool-domain.com'
3. Follow the Prompts:
   Press Enter to accept the default file location (typically ~/.ssh/id_rsa). Choose a secure passphrase when prompted or press enter again to continue without a passphrase.
4. Verify Your SSH Keys:
   To display your public key, type: cat ~/.ssh/id_rsa.pub.

Conclusion

Congratulations you have successfully learnt how to generate SSH key pairs. This is a fundamental skill for your IT Toolbox. Remember to keep your private key safe and secure. In a later tutorial, we will learn different ways we can use these keys to enhance your IT workflows.

I encourage you to share your thoughts and ask questions in the comments!

Thank you!

But, fret not!!! It is possible to update to a major platform version using the AWS Command Line Interface (CLI):

aws elasticbeanstalk update-environment --solution-stack-name "64bit Amazon Linux 2 v3.2.0 running PHP 8.0" --environment-id "x-xxxxxxxxxx" --region "us-west-1"

To find the newest PHP platform version AWS Elastic Beanstalk supports view the Elastic Beanstalk Supported Platforms.

For previous versions see the PHP Platform History.