DEV Community: Gerardo León

Rotate AWS IAM Access Keys by script

Gerardo León — Thu, 06 Aug 2026 04:50:33 +0000

Update (2026): This article documents a legacy approach and is preserved for historical and educational purposes. AWS now recommends temporary credentials through IAM Identity Center for human access and local development, and IAM roles for workloads, instead of long-term IAM user access keys whenever possible.

The 12-hour expiration described below applied to temporary credentials or an organization-specific setup; IAM user access keys do not expire automatically. The original script also deletes the oldest key before validating the replacement and overwrites the default profile in .aws/credentials. Do not use it unchanged in a production environment. A safer rotation flow is: create the new key, configure and test it, deactivate the old key, verify that it is no longer used, and only then delete it.

Context

Provided IAM access keys were set to expire in 12 hours. Developing locally constantly resulted in Token expired exceptions.

Solution

Create an IAM user access key on demand through a script, following AWS recommendations to rotate access keys periodically.

Problem

Creating these access keys and adding them to the .aws/credentials file is a very manual process.

Solution

Script the whole process through the AWS CLI.

Required

An IAM user name.
A valid access key for the one-time setup.

Requirements

Given one valid IAM access key for the IAM user, create another access key and configure it under the default profile in .aws/credentials.

Given two valid IAM access keys for the IAM user, delete the oldest one and then create a new one.

Script

# Assuming AWS CLI is installed and you have sufficient permissions
param (
    [Parameter(Mandatory=$true)]
    [string]$IAMUserName
)

# Fetch the access keys for the user
$keys = aws iam list-access-keys --user-name $IAMUserName | ConvertFrom-Json

# If 2 keys exist, delete the oldest one
if ($keys.AccessKeyMetadata.Count -eq 2) {
    # Sorting by CreateDate to find the oldest key
    $oldestKey = $keys.AccessKeyMetadata | Sort-Object CreateDate | Select-Object -First 1

    # Delete the oldest key
    aws iam delete-access-key --user-name $IAMUserName --access-key-id $oldestKey.AccessKeyId
}

# Create a new access key
$newKey = aws iam create-access-key --user-name $IAMUserName | ConvertFrom-Json

# Write to the .aws/credentials file
$credentialsPath = "$env:USERPROFILE\.aws\credentials"
$credentialsContent = @"
[default]
aws_access_key_id = $($newKey.AccessKey.AccessKeyId)
aws_secret_access_key = $($newKey.AccessKey.SecretAccessKey)
"@

# Overwrite the credentials file with the new keys
# You might want to append or edit it if you use multiple profiles
Set-Content -Path $credentialsPath -Value $credentialsContent

Write-Output "Updated .aws/credentials with new access keys."

Usage

.\RotateKeys.ps1 -IAMUserName "YourIAMUserName"

Preconditions

AWS CLI installed.
An AWS IAM user created.
Sufficient IAM permissions to list, create, deactivate, and delete access keys, according to the rotation process you implement.

References

Tinkering with ChatGPT: Gmails to Trello cards

Gerardo León — Thu, 06 Aug 2026 04:19:35 +0000

Update — August 2026

This article documents an experiment originally published in April 2023. The Gmail-to-Trello concept and both APIs remain available, but the linked implementation should now be treated as an unmaintained experimental prototype, not as a production-ready or plug-and-play tool.

The repository targets the unsupported Node.js 16 runtime and uses pkg, which was archived in 2024. It also requires security and reliability fixes, including removing credentials from logs, correcting email deduplication and startup behavior, improving Gmail time-based queries, and adding safer error handling.

Do not run the current repository with real Gmail or Trello credentials without first reviewing and updating the code and its dependencies. If you test it, use non-production accounts, least-privilege credentials, and revoke the tokens afterward.

Photo by Rolf van Root on Unsplash.

Why ChatGPT?

As a manager, my coding duties have reduced drastically. So, looked everywhere to build or automate something that could impact any close one’s work. Found ChatGPT could be a helper to get some inspiration.

Use case

Someone close does some grunt work that constraints it to share a Gmail account with other three people.
Work is distributed by emails, each member has to pick their corresponding emails and address them.
Problem: most of the times, someone opens an email that does not matter to its responsibility, and leaves it marked as read; so confusion as to if that email was addressed takes over the place.

What’s in the market?

My diagnostic is the group is prone to carelessly leave emails read by any reason; so my solution, after speaking with the affected, is to move the emails to a place where their state is visible and it’s easier to distribute tasks to the responsible ones. The most common tool for transparentizing such type of workspace, to me, is Trello or any board-like tool, besides that has a free tier, accessible to many users, and allows to order work in lists.

Did some research prior to get dirty with code, found there’s a Trello add-on for Gmail. However, it ain’t cool enough: asks to open a mail to see the add-on in action, this did not avoid the scenario were oblivious users could skip creating Trello cards for each email read. Besides that did not provide any way to automate card creation. So that was a no-way.

Without further ado, hands on work…

Solution

There, I came up with some requirements:

Tool should create cards automatically based off a emails from an account.
Tool should not prompt user for any input once it’s setup.
Tool should create cards on a time basis.
Tool should integrate with Gmail and Trello.
Tool should be a plug-and-play thingy.
Cards should be concesive enough and avoid to copy-paste all of the email contents.
Cards should not duplicate.

From there, the inputs and outputs define as:

Inputs: Gmail credentials, Trello integration requirements, user preferences on time basis for these cards to create, target Trello list, target Trello board.
Outputs: Trello cards in given Trello list of a Trello board.

Caveats

I already mentioned I don’t code much often, and have got a bit dusty so decided to use ChatGPT for this journey.
Trello has its capricious way to integrate with custom tools, so that adds a bit of overhead to the final solution.

Talk is cheap, show me the code:

Below is the link to the GitHub repo, where I include prompts used with ChatGPT in prompts.txt:

nosavvy33/gmails-to-trello on GitHub

Next steps

See if this can become a Google add-on so that setup overhead reduces.

Final words

Surprised about how good of a work starter ChatGPT can be, no doubt it still needs polishing and human intervention for its proposed solutions to work. Personally, I come from another profession menaced by AI: translator; where there’s a saying “machine translation will replace translators that translate like machines”. I think of ChatGPT the same way, machine-generated software will replace software developers that write software as machines.

Connect your Github repo to NPM for package deployments

Gerardo León — Sat, 01 Aug 2026 21:41:18 +0000

Most important... 🧐

You should have already a library to publish to npm, if not, you can follow my previous tutorial, it will have you ready for this post 😀

The NPM fun: first publish 👨‍💻

Now we are ready for the NPM fun, add these two scripts to your root package.json:

"build-lib": "ng build custom-ui",
"publish-lib": "npm run build-lib && npm login && npm publish ./dist/custom-ui --access public",

Also, make sure to add these lines to the library's package.json:

"name": "@gblp/custom-ui", <--- make sure you include your npm username
...
"repository": {
    "type": "git",
    "url": "git+https://github.com/elparaquecosadeque/npm-test.git"
  },
  "publishConfig": {
    "access": "public"
  }

After doing so, run this in your terminal:

npm run publish-lib

And your terminal should prompt you for login to npm and then publish

There is our package is already published to NPM:

Let's automate through Github Actions 🐙

Create a .github/workflows directory in your root, and then a publish.yml resembling below:

name: Publish npm package

on:
  workflow_dispatch:

permissions:
  contents: read
  id-token: write

jobs:
  publish:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v5

      - uses: actions/setup-node@v5
        with:
          node-version: 24
          cache: npm
          registry-url: https://registry.npmjs.org

      - run: npm ci --ignore-scripts
      - run: npm run build:lib
      - run: npm publish ./dist/custom-ui --access public --provenance

Push it and let's go to npm interface. There click on Settings > in Trusted Publisher, enable GitHub Actions:

This will ask you in the form for some details you are good to fill out:

Finish with Setup connection button and you're done here:

Github side: trigger NPM publish 🚀

In your repo, go to Actions > Under Actions, "Publish npm package" > Run workflow

As we have defined the trigger workflow_dispatch this means the trigger is manual, let's give it the first go by click on "Run workflow"

Beware: Version conflict 🚀

If you followed to the letter, you must have come across the error below:

This is quite expressive: NPM cannot publish over previous versions. Let's quickly fix by adding to our projects/custom-ui/package.json:

  "version": "0.0.2",

With that, let's try again:

And now lovingly crafted 💓, we see it mirrored in your NPM profile:

Achievements 🎉🙌

Created your first NPM package for reusability in your multiple projects
Integrated CI/CD for your repo
Revisit the repo to verify if you missed something: https://github.com/elparaquecosadeque/npm-test

Create your first Angular components library

Gerardo León — Sat, 01 Aug 2026 05:30:58 +0000

Build the local lib 🔨🤓

To create an angular components lib, we add an parameter to the usual "ng new":

ng new npm-test --create-application=false

cd npm-test

ng generate library custom-ui --prefix ui

ng generate component components/button --project=custom-ui

This will get you a simple component called button in projects/custom-ui/src/lib

Optional: Build a tester app 📖*️

We create a test app to see what we built in our library. For so, run the following:

ng generate application library-tester

There, to invoke the library in the library-tester app, do:

1) Export the component in *public-api.ts * by copying the line below:

export * from './lib/components/button.component/button.component';

2) Import the component in the library-tester app:

// app.ts
import { Component, signal } from '@angular/core';
import { RouterOutlet } from '@angular/router';
import {ButtonComponent} from 'custom-ui';

@Component({
selector: 'app-root',
imports: [RouterOutlet, ButtonComponent],
templateUrl: './app.html',
styleUrl: './app.css',
})
export class App {
protected readonly title = signal('library-tester');
}

// app.html
<ui-button></ui-button>

Run these to verify in two different terminals:

ng serve --project=library-tester

ng build custom-ui --watch

Once done, in your localhost you should get something close to this:

Let's make the component configurable 🌶️🔥

Do the following changes:

1) In button.component.html:

    <button class="custom-btn" [style.background-color]="color">
      {{ text }}
    </button>

2) Your button.component.ts should resemble this:

import { Component, Input } from '@angular/core';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'ui-button',
  standalone: true,
  imports: [CommonModule],
  templateUrl: './button.component.html',
  styleUrls: ['./button.component.css']
})
export class ButtonComponent {
  @Input() text: string = 'Click me';
  @Input() color: string = '#f68f3b';
}

2.a) Optional, add some custom css:

.custom-btn {
  background-color: #3b82f6;
  color: white;
  border: none;
  padding: 10px 20px;
  border-radius: 4px;
  cursor: pointer;
}
.custom-btn:hover {
  background-color: #2563eb;
}

3) In the library tester's app.html you can now pass those variables in the DOM definition:

<ui-button text="Hey there!" color="blue"></ui-button>

By doing all these steps, now your component should look like below:

Achievements 🎉🙌

Created your first Angular library for reusability in your multiple projects
Keep style, look-and-feel consistency across your apps
Revisit the repo to verify if you missed something: https://github.com/elparaquecosadeque/npm-test

What's next 🏁🤓

In this next article, we will learn to publish our Angular components library to npmjs (NPM) to make it available thru npm install command

Happy coding! 👨‍💻