Creating a Blog with Automated Posting Using PowerShell

Introduction#

Welcome to this walkthrough! Here, I’ll share how I created my blog and automated its updates using PowerShell. This post covers the writing platform, the automation process, and how to set up a webhook for instant deployment without manual intervention. Along the way, I’ll also discuss challenges I faced and how I resolved them. Let’s dive in!

Prerequisites#

Before starting, there are several tools and prerequisites required:

  1. Obsidian: A note-taking application where I draft blog content before publishing.
  2. Python: Used for scripting and testing.
  3. PowerShell: For scripting and automation.
  4. Git: For version control and interaction with GitHub.
  5. Go: Required to make Hugo work for static site generation.
  6. Hugo: A static site generator with ready-made templates for easy customization.

Additionally, you’ll need a functional website and a GitHub repository to host your blog.

Note: This guide assumes you’re using Windows. While Mac and Linux can also be used, I won’t cover their differences here.

Following NetworkChuck’s Tutorial#

This project was inspired by NetworkChuck’s YouTube video titled “I started a blog… in 2024 (why you should too).” I followed the tutorial while adding my own adjustments and solving issues along the way. Although many platforms were new to me, the process was a fantastic learning experience, and I encourage you to give it a try!

Step 1: Setting Up the Tools#

Obsidian#

Obsidian is a fantastic note-taking tool. Its intuitive design and search functionality make organizing and reviewing notes effortless. I regret not discovering it sooner! If you’re still using Word documents for notes, I highly recommend switching to Obsidian. Detailed setup instructions are in my GitHub repository under “Cybersecurity Projects.”

Hugo#

Hugo is a static site generator where I found the template for my blog. Initially, I tried customizing other themes but struggled due to limited CSS knowledge. Ultimately, I settled on the Terminal theme for its simplicity and flexibility. Download and setup instructions for Hugo are also available in my GitHub repository.

Issue: Customizing themes was overwhelming due to my limited CSS knowledge. Solution: I focused on the Terminal theme, which had detailed documentation and straightforward setup steps.

Step 2: Preparing the Environment#

  1. Navigate to your working directory in PowerShell where your Obsidian files are stored.

  2. Create a Posts folder to house your blog posts.

  3. Move to your desired location for the Hugo site and initialize it with:

    hugo new site <site-name>

  4. Initialize a local Git repository:

    git init
git config --global user.name "<your_username>"
git config --global user.email "<your_email@example.com>"

  5. Create two folders:

    • Posts in <site-name>/content/Posts for blog content.
    • Images in <site-name>/static/images for post images.

Issue: Misplaced directories caused build errors. Solution: Carefully reviewed Hugo’s documentation to understand proper folder structures.

Step 3: Installing a Hugo Theme#

Download the Terminal theme with:

git submodule add -f https://github.com/panr/hugo-theme-terminal.git themes/terminal

Configure the theme by copying the settings from its README file into your hugo.toml file located in <site-name>/config.toml. This ensures the theme renders correctly when you compile the site.

Issue: Misconfiguring hugo.toml led to broken layouts. Solution: Referred back to the theme’s README for precise configuration details.

Step 4: Moving Blog Content from Obsidian to Hugo Website#

Moving Markdown Files#

Use robocopy to sync blog posts from Obsidian to Hugo:

robocopy C:/<Obsidian-path>/Posts C:/<Hugo-site>/content/posts /mir

Managing Images#

This Python script, from NetworkChuck, automates moving images, edits for removing a preceding ! that posted with the image:

import os
import re
import shutil

# Paths
posts_dir = r"C:\path\to\hugo\content\posts"
attachments_dir = r"C:\path\to\obsidian\attachments"
static_images_dir = r"C:\path\to\hugo\static\images"

# Process markdown files
for filename in os.listdir(posts_dir):
    if filename.endswith(".md"):
        filepath = os.path.join(posts_dir, filename)
        with open(filepath, "r", encoding="utf-8") as file:
            content = file.read()
        
        # Find and update image links
        images = re.findall(r'\[\[([^]]*\.png)\]\]', content)
        for image in images:
            markdown_image = f"/images/{image.replace(' ', '%20')}"
            content = content.replace(f"[[{image}]]", markdown_image)
            
            # Copy images
            image_source = os.path.join(attachments_dir, image)
            if os.path.exists(image_source):
                shutil.copy(image_source, static_images_dir)
        
        with open(filepath, "w", encoding="utf-8") as file:
            file.write(content)

print("Markdown files processed and images copied successfully.")

Save this script as images.py in your Hugo folder and run it in PowerShell with:

python ./images.py

Issue: Broken image links in Markdown files. Solution: The Python script automatically fixed the image paths and moved the images to the correct folder.

Step 5: Configuring GitHub and Hostinger#

  1. Create a GitHub repository for your blog.

  2. Set up SSH authentication:

    ssh-keygen -t rsa -b 4096 -C "<your_email@example.com>"
ssh -T git@github.com

  3. Add a remote repository:

    git remote add origin git@github.com:<username>/<repository>

  4. Push updates to GitHub:

    hugo
git add .
git commit -m "Initial commit"
git push -u origin master

  5. Use git subtree to create a deployable branch for Hostinger:

    git subtree split --prefix public -b hostinger-deploy
git push origin hostinger-deploy:hostinger --force
git branch -D hostinger-deploy

  6. In Hostinger, create a subdomain for your blog, generate an SSH key, and set up a webhook to automate deployments.

Issue: Webhook failed to trigger deployments initially. Solution: Debugged the webhook setup by reviewing Hostinger logs and corrected a URL misconfiguration.

Step 6: Manual testing to make sure the process works from start to finish#

Here’s the PowerShell script to automate the process:

$sourcePath = "C:\path\to\obsidian\posts"
$destinationPath = "C:\path\to\hugo\content\posts"
$myRepo = "git@github.com:<username>/<repository>"

# Sync posts
robocopy $sourcePath $destinationPath /mir

# Process markdown files
python ./images.py

# Build site
hugo

# Push to GitHub
Set-Location "C:\path\to\hugo"
git add .
git commit -m "Automated update"
git push -u origin master

git subtree split --prefix public -b hostinger-deploy
git push origin hostinger-deploy:hostinger --force
git branch -D hostinger-deploy

Step 7: Single script uploads with PowerShell#

To fully automate the process, we use a PowerShell script created by NetworkChuck with edits to run on my computer

# PowerShell Script for Windows
# Set variables for Obsidian to Hugo copy
$sourcePath = "C:\Users\path\to\obsidian\posts"
$destinationPath = "C:\Users\path\to\hugo\posts"
# Set Github repo 
# The <user_name> & <repo_name> need to be changed to fit your user name and repo name
$myrepo = "git@github.com:<user_name>/<repo_name>.git"
# Set error handling
$ErrorActionPreference = "Stop"
Set-StrictMode -Version Latest
# Change to the script's directory
$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
Set-Location $ScriptDir
# Check for required commands
$requiredCommands = @('git', 'hugo')
# Check for Python command (python or python3)
if (Get-Command 'python' -ErrorAction SilentlyContinue) {
    $pythonCommand = 'python'
} elseif (Get-Command 'python3' -ErrorAction SilentlyContinue) {
    $pythonCommand = 'python3'
} else {
    Write-Error "Python is not installed or not in PATH."
    exit 1
}
foreach ($cmd in $requiredCommands) {
    if (-not (Get-Command $cmd -ErrorAction SilentlyContinue)) {
        Write-Error "$cmd is not installed or not in PATH."
        exit 1
    }
}
# Step 1: Check if Git is initialized, and initialize if necessary
if (-not (Test-Path ".git")) {
    Write-Host "Initializing Git repository..."
    git init
    git remote add origin $myrepo
} else {
    Write-Host "Git repository already initialized."
    $remotes = git remote
    if (-not ($remotes -contains 'origin')) {
        Write-Host "Adding remote origin..."
        git remote add origin $myrepo
    }
}
# Step 2: Sync posts from Obsidian to Hugo content folder using Robocopy
Write-Host "Syncing posts from Obsidian..."
if (-not (Test-Path $sourcePath)) {
    Write-Error "Source path does not exist: $sourcePath"
    exit 1
}
if (-not (Test-Path $destinationPath)) {
    Write-Error "Destination path does not exist: $destinationPath"
    exit 1
}
# Use Robocopy to mirror the directories
$robocopyOptions = @('/MIR', '/Z', '/W:5', '/R:3')
$robocopyResult = robocopy $sourcePath $destinationPath @robocopyOptions
if ($LASTEXITCODE -ge 8) {
    Write-Error "Robocopy failed with exit code $LASTEXITCODE"
    exit 1
}
# Step 3: Process Markdown files with Python script to handle image links
Write-Host "Processing image links in Markdown files..."
if (-not (Test-Path "images.py")) {
    Write-Error "Python script images.py not found."
    exit 1
}
# Execute the Python script
try {
    & $pythonCommand images.py
} catch {
    Write-Error "Failed to process image links."
    exit 1
}
# Step 4: Build the Hugo site
Write-Host "Building the Hugo site..."
try {
    hugo
} catch {
    Write-Error "Hugo build failed."
    exit 1
}
# Step 5: Add changes to Git
Write-Host "Staging changes for Git..."
$hasChanges = (git status --porcelain) -ne ""
if (-not $hasChanges) {
    Write-Host "No changes to stage."
} else {
    git add --renormalize .
}
# Step 6: Commit changes with a dynamic message
$commitMessage = "New Blog Post on $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
$hasStagedChanges = (git diff --cached --name-only) -ne ""
if (-not $hasStagedChanges) {
    Write-Host "No changes to commit."
} else {
    Write-Host "Committing changes..."
    git commit -m "$commitMessage"
}
# Step 7: Push all changes to the main branch
# Be sure to edit the location of your rsa key if it is not located in your ~/.ssh/ directory
Write-Host "Deploying to GitHub Master..."
try {
    git -c core.sshCommand="ssh -i ~/.ssh/secondary_rsa_key" push origin master
} catch {
    Write-Error "Failed to push to Master branch."
    exit 1
}


# Step 8: Push the public folder to the hostinger branch using subtree split and force push
Write-Host "Deploying to GitHub Hostinger..."
# Check if the temporary branch exists and delete it
$branchExists = git branch --list "hostinger-deploy"
if ($branchExists) {
    git branch -D hostinger-deploy
}
# Perform subtree split
try {
    git subtree split --prefix public -b hostinger-deploy
} catch {
    Write-Error "Subtree split failed."
    exit 1
}
# Push to hostinger branch with force
try {
    git push origin hostinger-deploy:hostinger --force
} catch {
    Write-Error "Failed to push to hostinger branch."
    git branch -D hostinger-deploy
    exit 1
}
# Delete the temporary branch
git branch -D hostinger-deploy
Write-Host "All done! Site synced, processed, committed, built, and deployed."

Overcoming Challenges While Running the Script#

This is where I ran into the most problems. Unfortunately, the code didn’t immediately work for me because of a couple of issues I encountered.

The first issue arose when running git add .—the script exited unexpectedly. After some investigation, I discovered that the line endings in Windows needed to be converted to a Linux-readable format (CRLF: carriage return + line feed). For some reason, this broke the code and returned an error. My immediate fix was to change a Git core setting using core.autocrlf = true, which was supposed to automatically convert LF to CRLF and allow the script to work.

While this worked in the short term, the code would still break intermittently, even though the warning was informational and didn’t seem to affect the actual script execution. The struggle came from my lack of experience with creating PowerShell scripts. To troubleshoot, I took the problematic portion of the code and error message to ChatGPT, where I explored the issue further and found a more robust solution.

Ultimately, I needed to create a new file in the Git settings called .gitattributes and include the line * text=auto. Additionally, I had to add the --renormalize flag to the git add . command so that when changes were added to the local repository, line-ending normalization was explicitly enforced. This resolved the issue by ensuring compatibility with Linux line-feed standards, effectively preventing further errors.

The second issue involved my RSA key, which is password-protected to add a layer of security in case someone gains access to my computer. This password protection caused the script to break during the push portion. The initial fix involved caching the password, but this defeated the purpose of the password protection on the RSA key. After further research, I decided to create a secondary key and added its specific location to the script. This approach preserved the security of my primary key while allowing the script to run seamlessly.

Finally, after addressing these challenges, I ran the script again and felt a wave of relief when I checked the website and saw that the changes had posted immediately.

Step 7: Automating the Process with Task scheduler#

Task Scheduler to run the script periodically:

  1. Open Windows Task Scheduler and create a new task.
  2. In the “General” tab:
    • Provide a name for the task, e.g., “Automate Blog Updates.”
    • Select “Run whether user is logged on or not.”
    • Check “Run with highest privileges.”
  3. In the “Triggers” tab:
    • Add a new trigger to specify when the task should run (e.g., daily or weekly).
  4. In the “Actions” tab:
    • Add a new action and set “Action” to “Start a program.”
    • In the “Program/script” field, enter the path to powershell.exe.
    • In the “Add arguments” field, include the path to your script, e.g., `-File C:\path\to\

Conclusion#

This project was a rewarding experience that combined multiple tools and scripting techniques. Automating the blog updates has saved me time and effort, allowing me to focus more on creating content rather than manual updates. Now, all I have to do is drag and drop pending posts into the live file, which automatically updates the blog page.

While I don’t have a set upload schedule yet, I plan to upload cybersecurity projects regularly and aim for a weekly schedule in the future—so keep an eye out for updates! If you have any topics you’d like me to cover or think could help me round out my knowledge base for defensive security, feel free to reach out.

I hope this guide inspires you to start your own blog or automate parts of your workflow. Happy blogging!