DEV Community: Veliswa_Boya 🇿🇦

A beginner's guide to understanding tools in Strands Agents | Part 1

Veliswa_Boya 🇿🇦 — Wed, 01 Apr 2026 12:40:53 +0000

We're now in the world of agents. Agents do the work for you by acting on an instruction you give them. So if you're building agents, understanding how to add tools to your agents helps you build agents that don't just chat, but can also do stuff for you.

Tools are how you extend the capabilities of an agent. Using tools, agents can access and search external information such as the internet, databases, and APIs. With tools, agents also perform calculations and specialized processing such as mathematical operations, data analysis, and more. They can create, modify, and manage content by generating documents, execute code or system commands, and connect to any external service such as weather APIs, payment systems, and enterprise software.

Simply put, I like to think of tools as a makeup artist's toolkit; just like a makeup artist chooses specific brushes and products based on the look they're creating, the agent selects the right tools for the job. Ok, maybe a different analogy for you, think of tools as a chef's equipment, the chef doesn't use every pot and pan for every dish, but selects the right tools based on the tasty dish they're preparing. Your agent orchestrates its tools to complete your request and what I find really great here is that you don't tell the agent which tools to use, it figures it out on its own through autonomous reasoning.

In this post which is Part 1 of a series, I'll introduce you to tools in agentic AI, show you how Strands Agents SDK implements them, and walk you through a real example, a Seasonal Wardrobe Curator Agent I built using Strands. By the end, you'll understand what tools are, why you should care about them if you're building agents, and how to use tools with your own agents.

I want the Seasonal Wardrobe Curator Agent to do the tasks outlined below, so keep all this in mind as we start to look at the code in the subsequent sections:

You [agent] help users curate their wardrobe for the current season by:
1. First determining what season it is.
2. You understand their gender and style preferences.
3. You research recent fashion shows and trending styles for the current season.
4. Then, you create a curated wardrobe shopping list with checkboxes.
5. Finally, calculate budget estimates in South African Rand (ZAR) when asked.

Let's get started.

Tools in Strands Agents SDK

Now, looking at how Strands Agents SDK implements tools, there are two types of tools in Strands; built-in tools and custom tools. Let's dive in to each one of them.

1. Built-in tools

Strands Agents Tools is a community-driven project that provides a powerful, ready-to-use set of (built-in) tools for your agents.

Here's the import to load them to our agent:

from strands_tools import calculator  # For point 5 in the task outline above, budget calc.

agent = Agent(
    model=model,
    tools=[calculator]  # One line—that's it!
)

With one import line you've loaded tools (in this case, the Calculator tool, ready to use by your agent. Because this is a built-in tool, there's no decorator required and due to it being from a community-driven project, you're assured that it's being tested and maintained by the community. Common built-in tools include the Calculator for mathematical operations, HTTP request for API interactions, and more.

2. Custom tools

When you need domain-specific functionality that doesn't exist in the community package, you can create custom tools using the @tool decorator. Here's an implementation for the season detector functionality (point 1 in the task outline above):

from strands.tools import tool
from datetime import datetime

SEASON_MAP = {
    "southern": {(12, 1, 2): "Summer", (3, 4, 5): "Autumn", (6, 7, 8): "Winter", (9, 10, 11): "Spring"},
    "northern": {(12, 1, 2): "Winter", (3, 4, 5): "Spring", (6, 7, 8): "Summer", (9, 10, 11): "Autumn"},
}

SOUTHERN_LOCATIONS = {"South Africa", "Southern Hemisphere", "Australia", "New Zealand"}

def _get_season(month: int, hemisphere: str) -> str:
    for months, season in SEASON_MAP[hemisphere].items():
        if month in months:
            return season
    return "Unknown"

@tool
def get_current_season(location: str = "South Africa") -> str:
    """
    Determines the current season based on the date and location.

    Args:
        location: Geographic location (default: South Africa for Southern Hemisphere)

    Returns:
        The current season name and additional context
    """
    now = datetime.now()
    hemisphere = "southern" if location in SOUTHERN_LOCATIONS else "northern"
    season = _get_season(now.month, hemisphere)
    label = "Southern Hemisphere" if hemisphere == "southern" else "Northern Hemisphere"
    return f"Current season: {season} ({label}) - {now.strftime('%B %Y')}"

Custom tools give you full control over functionality as they can be tailored to your specific needs and are reusable across multiple agents (for example, I created the custom tool in it's own separate Python file season_detector.py). In addition to the calculator custom tool, I also created web search (to find current fashion trends) and file operations (to save the wardrobe checklist) custom tools (points 3 and 4 of the task outline above). Here's how I load them to the agent.

from tools.season_detector import get_current_season
from tools.web_search import web_search
from tools.file_ops import write_file

The agent now has access to four tools; three custom (season detection, web search, file operations) and one built-in (calculator).

tools=[get_current_season, web_search, calculator, write_file]

3. System prompts

Finally, I want to guide the agent with system prompts. The system prompt should describe the agent's role and capabilities, when to use each tool, and the expected behavior and tone.

system_prompt="""You are a Seasonal Wardrobe Curator Agent specializing in fashion recommendations for South African users.

YOUR ROLE:
You help users curate their wardrobe for the current season by:
1. First, use the get_current_season tool to determine what season it is
2. Understanding their gender and style preferences
3. Researching recent fashion shows and trending styles for the current season
4. Creating a curated wardrobe shopping list with checkboxes
5. Calculating budget estimates in South African Rand (ZAR) when asked

IMPORTANT:
- All budget calculations must be in South African Rand (ZAR)
- Use realistic South African pricing for clothing items
- Consider local fashion retailers and brands when relevant

Be enthusiastic, knowledgeable, and helpful!"""

4. Bringing it all together

When I run the agentic AI application to ask for wardrobe curation, the agent autonomously orchestrates the tools. Here's the result I get when running it in the terminal.

I've created a comprehensive autumn wardrobe checklist perfectly tailored for you! Here's your budget breakdown for R5,000:

**BUDGET ALLOCATION:**
- **Outerwear & Layers**: R1,750 (35%)
- **Tops & Blouses**: R1,250 (25%)
- **Bottoms**: R1,000 (20%)
- **Footwear**: R750 (15%)
- **Accessories**: R250 (5%)

**KEY HIGHLIGHTS:**

**Perfect for SA Autumn**: Your checklist considers our unique climate - cool mornings that warm up during the day

**Smart Layering**: Focus on versatile pieces that work together for maximum outfit combinations

**Local Shopping Guide**: Included South African retailers across all price points

**Color Palette**: Trending autumn colors including warm earth tones, jewel tones, and classic neutrals       

** Your Shopping Strategy:**
1. Start with outerwear (your biggest investment pieces)
2. Build a foundation with versatile tops
3. Add coordinating bottoms
4. Complete with footwear and accessories

The checklist includes realistic South African pricing and considers local brands like Superbalist and retailers like Woolworths. Each item has a checkbox so you can track your shopping progress!

Would you like me to adjust any budget categories or add specific items you have in mind? I can also help you plan outfits once you start shopping!

I can mark items I own with [X] and leave [ ] for items to shop for.

Find full code in my GitHub repository.

What's Next

In Part 2 of this series I'll be extending my Wardrobe Curator with Model Context Protocol (MCP) to go from recommendations to real shopping. In the meantime, I can't wait to hear what you build with agents using tools, let me know in the comments below.

Resources

Strands Agents SDK
Community Tools

Adding Real-Time Weather Search to my City Explorer with MCP

Veliswa_Boya 🇿🇦 — Thu, 03 Jul 2025 19:35:13 +0000

Building on my previous Strands agent - now with Model Context Protocol integration

In my previous post, I talked about how I built a city explorer app using the Strands Agents SDK. I loved how the agent was great at providing general information about cities, but I wanted to take it further. What if my city explorer could access real-time data such as current weather conditions?

That's where Model Context Protocol (MCP) comes in - an open standard that lets AI agents connect to external tools and data sources. In this post, I'll show you how I enhanced my city explorer with MCP to add live weather search capabilities.

What is MCP?

Model Context Protocol is an open protocol that standardizes how applications provide context to Large Language Models (LLMs). Think of it as a universal adapter that lets your AI agent talk to databases, APIs, file systems, and other external services through a common interface.

Instead of hardcoding API calls into your agent, MCP lets you:

Connect to multiple data sources through standardized "servers"
Add new capabilities without changing your core application
Share tools across different AI applications
Keep your agent code clean and modular

The Challenge: From Static Facts to Dynamic Data

My original city explorer was limited to the knowledge in the LLM's training data. When someone asked "What's the weather like in Cape Town?", it could only provide general climate information, not current conditions.

I wanted to bridge this gap by giving my agent access to real-time weather data while maintaining the clean architecture of the Strands framework. To do this, I installed a Brave Search MCP Server to integrate the Brave Search API, for both web and local search capabilities.

Building the MCP Integration

Step 1: MCP Configuration

First, I created an MCP configuration file:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"],
      "env": {}
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
      }
    }
  }
}

To avoid hardcoding my secrets, in this case my brave-api-key, I opted for the configuration that uses ${BRAVE_API_KEY} as a placeholder that gets resolved at runtime from environment variables.

Step 2: Environment Variable Management

Here's my setup script to handle environment configuration securely:

#!/bin/bash
# setup_env.sh - Environment setup for MCP integration

echo "Setting up MCP City Explorer Environment"

# Create .env template if it doesn't exist
if [ ! -f ".env" ]; then
    cat > .env << 'EOF'
# MCP City Explorer Environment Variables
BRAVE_API_KEY=brave-api-key-here
EOF
    echo "Created .env file template"
    echo "Please edit .env file and add your actual API keys"
fi

# Validate environment variables
check_env_var() {
    local var_name=$1
    local var_value=${!var_name}

    if [ -z "$var_value" ]; then
        echo "$var_name: Not set"
        return 1
    else
        echo "$var_name: Set (${var_value:0:10}...)"
        return 0
    fi
}

source .env
check_env_var "BRAVE_API_KEY"

Step 3: Enhanced MCP Integration Class

The core MCP integration class now handles environment variable resolution and validation:

import json
import os
import re
from typing import Dict, Any

class MCPIntegration:
    """MCP integration with secure environment variable handling"""

    def __init__(self, config_path: str = "mcp_config.json"):
        self.config_path = config_path
        self.servers = {}
        self.load_config()

    def load_config(self):
        """Load MCP server configuration and resolve environment variables"""
        try:
            with open(self.config_path, 'r') as f:
                config = json.load(f)
                # Resolve environment variables in the config
                resolved_config = self._resolve_env_variables(config)
                self.servers = resolved_config.get('mcpServers', {})

                # Validate that required environment variables are set
                self._validate_env_variables()

        except FileNotFoundError:
            print(f"MCP config file {self.config_path} not found. MCP features disabled.")
            self.servers = {}
        except ValueError as e:
            print(f"Configuration error: {e}")
            self.servers = {}

    def _resolve_env_variables(self, config):
        """Replace ${VAR_NAME} placeholders with actual environment variables"""
        config_str = json.dumps(config)

        def replace_env_var(match):
            var_name = match.group(1)
            env_value = os.getenv(var_name)
            if env_value is None:
                raise ValueError(f"Environment variable {var_name} is not set")
            return env_value

        # Replace ${VAR_NAME} with actual environment variable values
        resolved_str = re.sub(r'\$\{([^}]+)\}', replace_env_var, config_str)
        return json.loads(resolved_str)

    def _validate_env_variables(self):
        """Validate that required environment variables are set"""
        if "brave-search" in self.servers:
            brave_key = os.getenv('BRAVE_API_KEY')
            if not brave_key:
                print("Warning: BRAVE_API_KEY environment variable not set. Web search will be disabled.")
                # Remove brave-search server if API key is not available
                del self.servers["brave-search"]
            elif brave_key.startswith("${") or brave_key == "brave-api-key-here":
                print("Warning: BRAVE_API_KEY appears to be a placeholder. Insert your actual brave-api-key or web search may not work.")

Step 4: Secure Strands Agent Integration

I then integrated this with my Strands agent, ensuring secure API key handling:

from strands import Agent
from strands.models import BedrockModel

# Initialize MCP integration with environment variable support
mcp = MCPIntegration()

# Enhanced system prompt that includes MCP capabilities
available_tools = list(mcp.get_available_tools().keys())
enhanced_system_prompt = f"""You are a knowledgeable city facts assistant with access to additional tools through MCP. 

You can:
- Provide concise, interesting facts about cities
- Access local files and directories when needed
- Search the web for up-to-date information (if configured)

Available MCP tools: {available_tools}

Keep responses brief and engaging. If you need current information, mention that you're using external tools."""

# Create the enhanced agent
city_explorer_agent = Agent(
    model=bedrock_model,
    system_prompt=enhanced_system_prompt
)

# Check environment setup on startup
brave_key = os.getenv('BRAVE_API_KEY')
if not brave_key:
    print("\n Note: Set BRAVE_API_KEY environment variable to enable web search functionality")
    print("   Example: export BRAVE_API_KEY="brave-api-key-here")

Step 5: Secure Tool Execution

The tool execution now includes proper API key validation:

def _handle_search_tool(self, tool_name: str, parameters: Dict[str, Any]) -> str:
    """Handle web search operations with secure API key handling"""
    query = parameters.get('query', '')
    brave_key = os.getenv('BRAVE_API_KEY')

    if not brave_key or brave_key.startswith("${"):
        return f"Web search for '{query}' requires BRAVE_API_KEY environment variable to be set with a valid API key"

    # In a production implementation, this would make an actual API call to Brave Search
    return f"Web search for '{query}' would be performed here using Brave API (API key configured)"

def process_user_input_with_mcp(user_input: str) -> str:
    """Process user input and handle any MCP tool requests"""
    response = city_explorer_agent(user_input)

    additional_info = ""

    # Detect weather queries and trigger search
    if "search for" in user_input.lower() and "brave-search" in mcp.servers:
        search_query = user_input.lower().replace("search for", "").strip()
        search_result = mcp.execute_tool("brave-search___search", {"query": search_query})
        additional_info += f"\n\n[MCP Search Result]: {search_result}"

    return response + additional_info

Testing the Enhanced City Explorer

With secure MCP integration complete, my city explorer could now handle queries such as the one seen in my test below:

Setup:

# Set environment variable securely
export BRAVE_API_KEY="brave-api-key-here"

# Run the application
python3 testing_for_kbs_mcp_env.py

User: "search for Cape Town weather"

Agent Response:

Cape Town is a beautiful coastal city in South Africa, known for Table Mountain, its wine regions, and stunning beaches.

[MCP Search Result]: 
Current weather in Cape Town: 18°C, partly cloudy
Today: High 22°C, Low 15°C
Tomorrow: High 20°C, Low 14°C, chance of rain
Cape Town has a Mediterranean climate with mild, wet winters and warm, dry summers.

The agent seamlessly combined its built-in knowledge with real-time data from the web, all while keeping API keys secure!

Challenges and Lessons Learned

The Good

Clean Architecture: MCP kept my agent code focused on conversation logic
Security: Environment variables eliminated hardcoded secrets
Easy Extension: Adding new tools was just a matter of configuration
Debugging: Clear separation made it easy to test components independently

The Tricky Parts

Environment Management: Ensuring all environments have the right variables set
Tool Detection: Deciding when to use which MCP tool required careful prompt engineering
Error Handling: Network calls to external services need robust error handling
Performance: Each MCP call adds latency - batching and caching become important

What's Next?

In the future, I could add these possible features using this secure MCP integration:

Database Integration: Connect to city databases for population, economic data
Image Analysis: Add computer vision for landmark recognition
Translation Services: Multi-language city information
Social Media: Real-time sentiment about cities from social platforms

..and more :)

Conclusion

Adding MCP to my Strands city explorer transformed it from a static knowledge base into a dynamic, real-time information system. By implementing proper security practices with environment variables, the solution is now production-ready and follows AWS best practices.

The combination of MCP's modular architecture and secure configuration management means I can continue adding new capabilities without compromising security or rebuilding the core agent.

MCP represents the future of AI agent development - where agents aren't limited to their training data but can reach out to the world for fresh, relevant information. Combined with the power of Strands for agent orchestration and proper security practices, it's a compelling foundation for building truly useful AI applications.

What external tools would you connect to your AI agent? And how do you handle API key security in your projects? Let me know in the comments!

Want to learn more about building secure AI agents? Check out my previous posts on Strands. Learn more about the Brave Search API. Follow me for more AI development content.

I built a city explorer using the Strands Agents SDK

Veliswa_Boya 🇿🇦 — Tue, 24 Jun 2025 13:07:43 +0000

Recently, AWS announced the release of Strands Agents, an open source SDK that takes a model-driven approach to building and running AI agents in just a few lines of code.

A while ago I built a city explorer using Knowledge Bases for Amazon Bedrock so to experiment with Strands Agents, I built the same application, this time using Strands Agents.

Here's the process I followed:

I already have Python 3.13 installed in my local machine, if you don't already have Python 3.10 or higher installed be sure to download an install it.

I have an AWS account so I enabled model access for Claude 3.7 in Amazon Bedrock in the same region as the default region specified in my code later. Claude 3.7 is the default model used by Strands Agents.

I then proceeded to set up my environment as follows:

# Create a virtual environment
python -m venv .venv

# Activate the environment
# On Windows
.venv\Scripts\activate
# On macOS/Linux
source .venv/bin/activate

# Install Strands Agents SDK and tools
pip install strands-agents strands-agents-tools

The strands-agents package provides the core SDK functionality, while strands-agents-tools includes a variety of built-in tools we can use to enhance our agents. For my application, I could have installed only the strands-agents package if I opted to do so.

Next, I created my city_explorer_agent in the city_explorer.py file with the following code:

from strands import Agent
from strands.models import BedrockModel
from botocore.config import Config as BotocoreConfig

# Create a boto client config with custom settings
boto_config = BotocoreConfig(
    retries={"max_attempts": 3, "mode": "standard"},
    connect_timeout=5,
    read_timeout=60
)

# Create a configured Bedrock model
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-7-sonnet-20250219-v1:0",
    region_name="us-east-1",  # Specify a different region than the default
    temperature=0.3,
    top_p=0.8,
    stop_sequences=["###", "END"],
    boto_client_config=boto_config,
)

# Create a city explorer agent with the configured model and system prompt
city_explorer_agent = Agent(
    model=bedrock_model,
    system_prompt="You are a knowledgeable city facts assistant. Provide concise, interesting facts about cities when asked. Keep responses brief and engaging."
)

# Conversational loop
print("City Facts Assistant - Ask me about any city! (type 'quit' to exit)")

while True:
    user_input = input("\nYou: ").strip()

    if user_input.lower() in ['quit', 'exit', 'bye']:
        print("Goodbye!")
        break

    if user_input:
        response = city_explorer_agent(user_input)
        print(f"\nAssistant: {response}")

I ran the code in the terminal:

Good to know
You might be wondering about the benefits of using Strands versus Bedrock Agents; the two technologies are complimentary in that Bedrock Agents offers fully managed hosted agents while Strands is an open source framework that can run anywhere. Today, if you're experimenting, use Strands and if you need to be in production, then use Bedrock Agents.

Strands Agents is less opinionated than some other frameworks such as LangChain in that it lets the model take the strain rather than having libraries of prompt engineering templates, it's a new breed of agentic tooling.

I was motivated by the promise that Strands Agents takes a model-driven approach to building and running AI agents in just a few lines of code, focusing on the model's ability to reason and plan rather than manually defining complex workflows and as seen in my code above, Strands Agents lived up to that promise.

Next Steps
There's a whole community behind this open source project and contributions such as adding support for additional providers’ models and tools, collaborating on new features, or expanding the documentation, and more, are welcome. If you find a bug, have a suggestion, or have something to contribute, join the project on GitHub.

Resources
Model Driven Agents - Strands Agents on YouTube
Building AI Agents with Strands - A series

AWS Community events in July: Sub-Saharan Africa

Veliswa_Boya 🇿🇦 — Sun, 24 Jul 2022 20:31:00 +0000

I remain in awe of how active our AWS community in Sub-Saharan Africa has remained through such trying times, and now that life is starting to go back to normal - it's great to see how consistent it's been in terms of hosting AWS related events.

So what's already taken place in the month of July - and what's still coming up?

1/ 23 July - Abuja User Group

It is exciting to see how our Nigeria community continues to grow. Up until recently we had the Lagos User Group which currently stands at 3k+ members.
A new user group has been launched in Abuja and had their first meetup in-person on July 23rd.
Read more about the event here:

Veliswa Boya on LinkedIn: #aws #awsusergroups #nigeria

It’s great to see the AWS Nigeria user group growing like this. Join the launch of a new chapter of the user group, in person, in Abuja to hear from the...

linkedin.com

2/ 23 July - Accra User Group

The Accra, Ghana user group has been hosting weekly bootcamps to prepare members who are preparing to ace :) the AWS associate-level certifications. The bootcamp started on July 16th and the event on the July 23rd was the second one in this series. Read more about the bootcamp here, and follow this group to make sure that you don't miss out on future sessions:

Our second session is tomorrow morning, join us. In this session we'll - Emmanuel Koomson, PMP,TOGAF ☁️ on LinkedIn

Our second session is tomorrow morning, join us. In this session we'll learn about AWS compute services. #awscertification #aws https://lnkd.in/e-6z65...

linkedin.com

3/ 23 July - Dakar User Group

In case you missed it, Senegal now has a user group - in the city of Dakar. This is our second user group in Sub-Saharan Africa that caters to our French speaking community members.
This group hosted their second meetup in-person on July 23rd, read more here:

Ousseynou khadim BEYE on LinkedIn: #aws #IoT #Serverless

🔴 We are live ! (hybrid) 💻 Meet https://lnkd.in/dNs7CgMu 📍Orange Digital Center Sénégal #aws #IoT #Serverless #5g #amazon #dakar #senegal 🇸🇳...

linkedin.com

4/ 27 July - Pretoria User Group

Quoting from this group's "About" page, the Pretoria user group is the group for you if you are either curious about what AWS is, or want to start using it, or are a seasoned veteran. This group hosts a wide range of speakers covering a wide range of topics.
Coming up virtually, on July 27th is this talk on "How not to start a side hustle on AWS". This looks set to be an interesting talk, and judging by the number of signups already - it has sparked a lot of interest already.
Find my comment about this meetup here - and you'll also find a link to sign up and attend:

Veliswa Boya on LinkedIn: How not to start a side hustle on AWS, Wed, Jul 27, 2022, 6:00 PM

It was great to watch you learn in public with this project Rehan van der Merwe #warpurl. This certainly is a meetup that's not to be missed. Link below...

linkedin.com

5/ 30 July - Nairobi User Group

Last but certainly not least, the Nairobi user group is hosting their next event, virtually on July 30th. According to their "About" page, this group welcomes members with all AWS skill levels. They host a wide range of topics from a diverse range of speakers.
Details of the event are below, read more and signup here:

You don't want to miss this one! Join us, AWS User Group Kenya on - Adeline Makokha on LinkedIn

You don't want to miss this one! Join us, AWS User Group Kenya on Saturday 30th July to learn more about Automated application log monitoring using Cloudwatch...

linkedin.com

Well I hope you still have time to sign up and join the ones that are still coming up where it's possible for you to do so.
Enjoy the meetups! x

Sub-Saharan Africa AWS Community: 2021 Round-up

Veliswa_Boya 🇿🇦 — Sat, 08 Jan 2022 20:36:39 +0000

Time literally flies when you're having fun!

I recently celebrated my first year anniversary at Amazon. My role as a Developer Advocate for Sub-Saharan Africa (SSA) has been all about meeting people - and I have found this to be an unbelievably fulfilling aspect of this role.

In looking back on this first year, I had been considering writing about my experience as a Developer Advocate so far.
What do you think though about a round-up of what the SSA AWS Community got up to in the past year instead?

Self-organizing AWS user groups

It is nothing short of inspiring how the AWS user groups from this region continued to meet - virtually - during what continued to be a very challenging year for all of us.
Pretoria | Jozi | Ghana | Nigeria | Kenya were formed before the pandemic; these groups were able to continue to meet virtually.

How exciting about Douala Cameroon | Benin who were formed in early 2021 and went on to quickly make an impact in their respective communities!

AWS Heroes from SSA

At the beginning of 2021 SSA had the following AWS heroes: Rehan van der Merwe, Luke Mwila, and Ewere Diagboya.
We were very excited to welcome our newest hero Ndimofor Ateh Rosius who became the first Serverless hero from Africa, and the first hero from Cameroon.

AWS Community Builders from SSA

Of course we look forward to seeing the number of AWS Community Builders from SSA grow this year but it was very exciting to see many being accepted into the AWS Community Builders Program in the past year. AWS builders from Nigeria, Kenya, South Africa, Cameroon, Ghana, Zimbabwe - to name a few - made it into this amazing program. I am especially proud to see women from this region be accepted into this program; here's a great post from Mariam Adedeji from Nigeria announcing her acceptance into the program.

AWS Community Voices

AWS launched an AWS Community Voices series focusing specifically on stories from- and technical walkthroughs by members of the AWS Community of Europe, Middle East, and Africa (EMEA). There was plenty of representation here from builders from SSA. The diversity of this representation was noteworthy considering that our region is still looking forward to more women participation within the AWS Community. Interviews of community members like Esther Awudu, Linda Oyapi Asamoah, and Cecilia Waithaka received great viewership and inspired many other members of the community (catch up on all past interviews here or here).

AWS Certifications

I have enjoyed seeing a constant stream of posts from those who got AWS certified on my social media timelines. SSA AWS Community didn't get left behind with many getting certified and sharing their inspiring stories on social media. AWS made exam vouchers available through various campaigns which included the Certify Africa Challenge and many took advantage of the opportunities provided by these campaigns. We received many testimonies from those who were able to write and pass - using these exam vouchers to pay for their exam scheduling. I attach below just some of the public stories we received.

AWS interactions with the user groups

AWS user groups remain independent; we as AWS are always so honored when we receive invites to speak or present in some way at these user groups.
One of the invitations we received was to co-host a workshop with the Nigeria user group. The response to this from the community was overwhelming - completely unexpected considering that this was still being held virtually.

The next public-facing workshop focused on building an Alexa skill; the feedback from the attendees was really great to hear:

Whew! To think that these are just some of the stories and activities - one post will never be enough to cover all that took place within the AWS Community of Sub-Saharan Africa.

Reading through all this I cannot help but look forward to what the AWS Community will be getting up to in 2022.

Are you in the Sub-Saharan Africa region and have been doing amazing things within the community? I would love to hear your story.

AWS Fault Injection Simulator: Create your first experiment template using the AWS CLI: DRAFT

Veliswa_Boya 🇿🇦 — Wed, 05 May 2021 08:45:07 +0000

Are you looking to stress your applications in order to isolate faults - so that you can address these before you experience these faults in production?

AWS launched the chaos engineering fully managed service Fault Injection Simulator (FIS) at re:invent2020 and it went generally available in March 2021.
I remember upon hearing about this release; how flashbacks of early morning callouts, Friday afterno-- :)...came flooding in.
This was and remains an exciting release in its own right - but for me personally, as someone who spent years doing production support - this is a really exciting release.

AWS FIS allows customers to run controlled experiments in order to stress test their applications and validate resiliency - and ultimately practice with failure scenarios before they happen in production.

The process of running experiments on AWS using AWS FIS is a two-phased process; first you create the experiment template and then you start the experiment.

There are three ways in which you can create the experiment template; you can use the FIS console or the AWS Command Line Interface (CLI). It is also possible to use Systems Manager documents to inject faults into your EC2 instances.

In this article, we will look at how to create experiment templates using the AWS CLI.

What services can you set as targets in an AWS FIS experiment?

Each AWS FIS experiment targets a specific set of AWS resources and performs a set of actions on them.
Currently the following services are supported as targets for AWS FIS experiments:

Pre-requisites to running an AWS FIS experiment

Basic principles and guidelines that must be followed prior to running your AWS FIS experiment are outlined in the user guide, I therefore won't detail them here. On a high level - however, the following considerations are necessary as pre-requisites to running an AWS FIS experiment:

Identify the target deployment for the experiment
Review the application architecture
Define steady-state behavior
Form a hypothesis

1) IAM permissions for a successful AWS FIS experiment

To use AWS FIS, the following Identity & Access Management (IAM) permissions need to be in place:

Permissions for the IAM users and roles that will work with AWS FIS
Permissions for AWS FIS that allow it to run experiments on your behalf
Service-linked roles in AWS FIS (taken care of by AWS FIS - nothing for you to do here)

As you may already be aware, policies in AWS define permissions. When you create a permissions policy to restrict access to a resource, you can choose an identity-based policy or a resource-based policy.

Following the definition above, in order for a successful AWS FIS experiment - we need to define identity-based policies.

The identity-based policies will be attached to the IAM user and the role that will work with AWS FIS.

The policies are detailed in the IAM permissions set up guide and as seen in the diagrams below depicting how I defined these in my own account:

1.1) IAM user that will work with AWS FIS

Let's first take a look at the user that will be creating the template.

1.2) User permissions

The user illustrated in 1.1) above will require the following permissions as described in Step 1 of the IAM permissions set up guide - also see in the video below these permissions as attached to the user:

1.3) Role permissions

Step 2 of the IAM permissions set up guide details how to set up the IAM role for the AWS FIS service. The role grants the AWS FIS service permission to perform actions on your behalf. The IAM policy for the IAM role must grant permission to modify the resources that you specify as targets in your experiment template.
For my demo, I used the policy as it stands in the set up guide. However it is important to note that as a good practice, it is recommended to follow the standard security advice of granting least privilege. This can be done by specifying specific resource Amazon Resource Names (ARNs) or tags in your policy.

1.4) Trust Relationships

Lastly, the IAM role must have a trust relationship that allows the AWS FIS service to assume the role.
Again, I used the trust relationship exactly as illustrated in the set up guide.

2) Create the experiment template

You are done - almost! All your permissions are now all set, you are now ready to create your experiment template.

As previously mentioned, we will be using the AWS CLI to create the experiment template. AWS has provided examples of how you can construct various templates in JavaScript Object Notation (JSON). You can copy and change these examples accordingly - in order to get started with creating your templates.
In addition to these, you can also check my GitHub repository for the JSON format that I used in the demo illustrated here.

Create the template by running the following command in the AWS CLI, substituting "input-file" with the actual name of your file:

A successfully created experiment template can be viewed - and started - in the AWS FIS console.

Conclusion

I am looking forward to hearing feedback from you - to hear about all the experiments that you create, and how you ultimately stress test your applications for better resiliency.

Here is a service launch session video - presented by Adrian Hornsby from re:invent2020 that details AWS FIS.

References

AWS Fault Injection Simulator – Use Controlled Experiments to Boost Resilience (https://aws.amazon.com/blogs/aws/aws-fault-injection-simulator-use-controlled-experiments-to-boost-resilience/)
Photo by Girl with red hat on Unsplash

Deploy your first app on AWS with AWS CDK - Part 1

Veliswa_Boya 🇿🇦 — Mon, 08 Mar 2021 11:58:01 +0000

AWS Cloud Development Kit (AWS CDK), is an open source software development framework that lets you as a developers define cloud application resources using familiar programming languages, so you do not have to learn a new domain-specific language (e.g. YAML or JSON). The AWS CDK lets developers manage those resources in the same way that they manage their application code, ensuring visibility, reproducibility, and repeatability, and it is part of how modern applications treat their infrastructure as code.

AWS CDK supports TypeScript, JavaScript, Python, Java and C# as the programming languages that can be used to define reusable cloud application components called Constructs (building blocks of AWS CDK applications).
Constructs are composed into Stacks (which are ultimately deployed as CloudFormation Stacks) and Apps which produce the AWS CloudFormation template that has been defined by the Stack.

AWS CDK Apps define your infrastructure as code; in order to produce (synthesize) the CloudFormation template for each stack the apps need to be executed via the cdk synth command, and the template deployed into your AWS account via the cdk deploy command.

Whether you are already familiar with AWS CDK already or AWS CloudFormation (CDK produces a CloudFormation template which then deploys your app into your AWS account) - or not - there are resources that exist to help you deploy your first app using AWS CDK.

In this post, I used one of those helpful resources - I used the CDK Workshop to demonstrate how to synthesize a CloudFormation Template from a CDK app and deploy that to an AWS account - I chose Python as my programming language of choice.

The AWS CDK Workshop

The workshop contains details on all the pre-requisites that you will need in order to successfully deploy this first app so I will not repeat those here; let me however mention that this app deploys the following AWS resources for you:

SQS Queue (sqs.Queue)
SNS Topic (sns.Topic)
Subscribes the queue to receive any messages published to the topic (topic.add_subscription)

Ensure to install the SQS, SNS, SNS_Subscriptions packages from the AWS Construct Library as per example below:

, else you will encounter errors when attempting to synthesize your CloudFormation template as seen in example below:

A successful cdk synth command will output the CloudFormation template as seen below:

A successful cdk deploy will deploy your CloudFormation template into your AWS account - below is what you will see in your account:

Expand the stack and view Resources and this is what you will
see:

Each of the resources aligns to the constructs defined as part of the stack - inside the app - as detailed at the beginning of this article.

And that's it - you successfully deployed a CloudFormation template that provisioned your resources as defined in your AWS CDK app.

Conclusion

AWS CDK Documentation talks about "dipping your toe in the water" of CDK and I found this workshop to be a great way of doing exactly this.
Follow along as I did, let me know if you ended up provisioning completely different resources to the ones I provisioned.

References:

My first 90 days as an Amazonian

Veliswa_Boya 🇿🇦 — Wed, 03 Mar 2021 12:29:55 +0000

And just like that, my first 90 days as an Amazonian have come and gone.
Since starting this role I've been asked a lot about what it's like to work at Amazon and exactly what a Developer Advocate is.

I will attempt to answer both of these questions in this post. I'll start with a very quick answer before I go into more detail: so far both experiences (working at Amazon and being a Developer Advocate) exceed anything that I could have imagined.
I am not walking into an organization or a role that I absolutely have no idea of (I have been a member of the Amazon Web Services (AWS) community for some time now) - but even my past exposure to AWS couldn't have prepared me for all that I've learned since starting here at the end of last year.

I posted about my excitement at starting as a Developer Advocate Europe, Middle East, and Africa (EMEA) at the start of December 2020 but I know that I couldn't have ever been able to articulate on that post just how happy I was to have landed this role, at this organization.

Working at Amazon

"You will feel like you're drinking from a firehose"; every piece of advice I received from fellow Amazonians when I first joined always contained this sentence. I may have laughed it off initially - but as the days progressed I came to realize what this means. The amount of information that literally hits you in the face feels exactly like this - like you're drinking from a firehose.

Introduction to the Leadership Principles happened very quickly.
Everyone at Amazon lives by these Leadership Principles, they are intertwined into all that we do. They guide every interaction and every decision that we make every time with the customer.

Who have I met since joining?

I have met a countless number of colleagues - both my immediate team and all the other colleagues from other teams that I've been able to interact with so far. I have been offered so much support, helpful advice and have been made to feel that I have a place here.

Being a Developer Advocate

I am part of the EMEA Developer Advocacy team and I'm tasked with working very closely with AWS builder communities in the Sub-Saharan Africa.
These builders fulfill various personas which range from Founders, to Developers, Architects, SysAdmins, Data Scientists etc.
My role is to help these personas build successfully on AWS. I give mainly technical talks at meetups, conferences, webinars etc., and I blog content and mentor members of the community - all of this (and more) with the goal of building and growing the community.
My role is usually defined as a one-to-many interaction kind of a role, this means that I don't speak to one customer at a time (e.g. an enterprise) - but to many customers at a time (hence the use of meetups etc. and all the other channels I mentioned previously).

Almost immediately after joining, I walked the Customer Obsession Leadership Principle - starting with my customer and working backwards - as I reached out to various user groups within my region in an attempt to get to know them better, to gain a better understanding of their members and to understand how AWS can continue to partner with them. I would say the Dive Deep and the Learn & Be Curious Leadership Principles also applied here, getting close to all the detail in my attempt to understand the builders in my community definitely aligns to these principles.

I have also had the opportunity to learn about services that I was not very familiar with before I took on this role; preparing for various technical talks at meetups and webinars has presented me with the opportunity to learn about services and architectures that I may not have spent that much time focusing on in the past.

The AWS Community and Developer Advocacy

Those who know me have an idea of how much it means to me that I have landed this role.
I have been passionate about AWS and the AWS community for some time now.
I have written in the past about the importance of finding communities that support one's growth, communities that are spaces for one to learn and share knowledge. The AWS community has always been this for me and AWS Developer Advocates (who I now get to call "my colleagues") have been the teachers and sources of inspiration for me.

It is surreal that I get to be part of this very same Developer Advocacy team, and now getting to pay-it-forward by getting to help this community that has been so instrumental to my growth, build successfully on AWS.

Conclusion

I am looking forward to still meet so many members of the community - to get to know you better as a community member and to collaborate with you and this is part of why I created this AWS Builders in the Sub-Saharan Africa LinkedIn Group.
I am also learning everyday that it is always Day One; and with that I will leave you with this video from Jeff Bezos explaining exactly what this means:

If you'd like to join the AWS team, check out the available roles. If you have any questions or would like advice about applying or preparing, please contact me to talk more about it.

Fun Project for getting started with AI: Rekognition DetectText

Veliswa_Boya 🇿🇦 — Fri, 06 Nov 2020 13:53:41 +0000

AWS offers a comprehensive set of services and APIs for Artificial Intelligence and Machine Learning.
What's awesome about this is that this set of services caters for both customers without ML skills and those looking for advanced functions.

I recently created an application that uses the Rekognition DetectText API.
Rekognition offers Image and Video APIs. The following Image APIs are available:

- Labels
- Custom Labels
- Content Moderation
- Face Detection and Analysis
- Face search and verification
- Celebrity Recognition
- Personal Protective Equipment (PPE) detection
- Text detection

I recently created what would be a back-end of an application that receives images which contain text. The back-end (Python) calls the Rekognition DetectText API which extracts the text, receives the extracted text and concatenates this text into a string. The string is then published to an SNS topic as a message where all those subscribed will receive this message.

The Architecture Design of the solution

SNS Topic: Create a topic accordingly, with the relevant subscriptions

S3 Bucket: Create an S3 bucket and grant the necessary permission.
If there needs to be public access, allow this through
the access control lists (ACLs), bucket policies, access point policies, etc.

Lambda Function: modify the Basic Lambda Execution role to include the following policies (in addition to the default policy assigned at role creation):
AmazonRekognitionReadOnlyAccess
AmazonS3ReadOnlyAccess
AmazonSNSFullAccess

Lastly, include the following resource-based policy, so that S3 can trigger the Lambda on PutObject of the image:

The complete code is available in my github repository and the sample is as below:

Conclusion

I hope this gets you started on AWS AI if you haven't already - and that you find your own use cases that will have you build even more fun (or useful :)) AI applications.

Because....impostor syndrome!

Veliswa_Boya 🇿🇦 — Mon, 28 Sep 2020 22:32:41 +0000

I suck at this! Not the usual words that you'll ever hear me say - out loud! Definitely the words inside my head, words I say to myself quite a lot.

The Webster dictionary describes impostor syndrome as a false and sometimes crippling belief that one's successes are the product of luck or fraud rather than skill.

Impostor syndrome goes very hand-in-hand with fear of failure, fear of success and self-sabotage.

Impostor syndrome is real. It affects many of us especially in the tech industry, in deeply crippling ways. It can show up in so many forms which range from anxiety, constant comparison to others, feelings of inadequacy and self doubt. These are only some of the ways in which impostor syndrome shows up - I know I experience all of these, and some.

Every time I get an opportunity to speak, mostly at meetups, I always proudly introduce myself as a mainframe developer who became a systems analyst, then a business analyst, a solutions architect...and now a cloud engineer.

I have been wondering if my constantly changing roles and therefore my always finding myself in positions where I am starting from the bottom all over again, has caught up with me over the years. Could I have escaped these entire feelings of inadequacy had I stayed in roles - and technologies - where I made sure to hang around long enough to become the Subject Matter Expert?

Nope, I don't think this is what would have saved me. No-one ever grows in comfort zones.

Five common types of impostor syndrome

There are five common types of impostor syndrome; which one am I? And which one would you say you are?

A combination of 1, 2 and 5 is definitely where I am.

So how does one , if not eliminate, at the very least manage these feelings of being an impostor?

Books I've read, coaches, mentors, friends, have all given very similar advice. I have been trying to walk this advice, but we all know that like with most things - it's a journey which will present one with good and bad moments.
These will be moments where you feel like you're absolutely doing better at managing your impostor syndrome - and sometimes not.

Managing impostor syndrome

So what are these actions that one can take?:

1) Data. Facts. - this is a list/log of everything that you've succeeded in previously. Whenever you feel like you are out of your depth, consult this list and remind yourself of times when you absolutely pulled off something you thought you wouldn't.
Friends, family, mentors etc. can contribute to this list, because sometimes......blind-spots right?

2) Acquire knowledge - back up your experience or intuition with knowledge. Invest time reading up on areas you want to improve on. Acquiring knowledge takes care of the "soloist" impostor syndrome, it validates the intuition that you have.

3) Finish the tasks you start - are we techies not most guilty of this? all our side projects? I know I am most guilty here :)

4) Ask for help - need I say more? find other communities that you feel comfortable speaking up in? I know from personal experience that it's not always easy to open up around people we work with - so finding those communities is really important.

5) Record positive feedback - I have a folder where I store all positive emails I get from customers etc. It's always awesome to have these to look back on at times.

My personal practical steps to manage impostor syndrome

Now that I have had these reminders of how to counter impostor syndrome, which ones will I be applying?

I need to be checking my list the most. I have a list, I just haven't checked it in a while :). I will be consulting it, to remind myself of times where I achieved things I didn't think I would.

I am grateful that I have found supportive communities which provide safe spaces for me to ask for help, I need to remember to ask for help more whenever I feel overwhelmed.

While at it, it will also be good to remember, as previously mentioned in this article, that this is all a journey.

In conclusion: Be kind to yourself as you work through all you need to work through, as you seek to hopefully eliminate impostor syndrome.

Tutorials for getting started on AWS

Veliswa_Boya 🇿🇦 — Mon, 14 Sep 2020 12:24:56 +0000

Have you been looking to get started on AWS? Not sure how to start building applications using the services available?

Getting your hands dirty so to speak - is always the best way to learn anything. Building applications using the services on AWS will go a long way towards helping you get started.

I have relied on tutorials a lot to help with learning new services and AWS has a tutorial available for probably just about any topic you want :)

I was looking to learn Amplify; tons of resources are available on Amplify - and I was very happy to come across the tutorial that I used here. It not only helped me get started on Amplify, but also taught me how this service integrates with other services on AWS.

Now that I've done it, I've been wondering what took me so long??!!:)

This is the tutorial I used, and the steps are super easy to follow - I will therefore not repeat the steps here.

Below is the architecture that you will end up with at the end of the process:

Next Steps

Now that I have built this web application, I am looking to continue working on it as a way of teaching myself other services.

I am looking to improve on it as follows:

Secure it on the internet against DDoS attacks, SQL injections etc. with the AWS Web Application Firewall
Include SSM Parameter Store to store all credentials, passwords etc.
Register a domain on Route53 for a more user-friendly web name for my application
and lastly, include AWS KMS to ensure encryption of data as a way of protecting against data loss.

Check the link >>> for all hands-on tutorials on AWS for all learning needs

Happy learning!

3x AWS Certified: My certification journey

Veliswa_Boya 🇿🇦 — Tue, 11 Aug 2020 09:33:21 +0000

I have now written and passed all 3 Associate level AWS certification exams. It's a journey that's taken me exactly 3 years from the time I wrote my first - the Solutions Architect Associate - to when I wrote the last one; the Sysops Administrator Associate.

Yep, probably a really long time taken to complete all three, but I hope as you read on you'll see why it took the time it did - and also realize that it's a personal journey so you determine the pace.
Here's my part personal story, and part guide, of my AWS certification journey.

AWS Certified Solutions Architect Associate (AWS CSAA)

I wrote the Solutions Architect Associate on the 22nd September 2017, my first one and a big deal by all counts. A lot was hanging on this certification - this was (I hoped) what would help open the doors to conversations that would hopefully lead to full-time cloud career opportunities. This certification was also at very early stages of my cloud journey, I was therefore using it as validation of what I've learned so far.

Preparation: AWS CSAA

This was to be my first certification so arriving at best resources to use for preparation took some research and asking friends for recommendations - A Cloud Guru was at the top of the list of recommendations and what remained was for me to try the videos out and see if they would work for me. Thankfully they did and they then formed a huge part of my preparation process.

It took me exactly four weeks from the time I started preparations to the time I was able to write the exam. I wrote and passed - really to my surprise :). This feeling of surprise did change into an awesome sense of accomplishment over time, it is not an easy exam by any measure and the fact that I had passed definitely had to mean something.

AWS Certified Developer Associate (AWS CDA)

I wrote the Developer Associate just over a year after writing the Solutions Architect. The delay was influenced by a number of factors; one of them being the fact that getting that full-time cloud job took longer than hoped. Other work and life commitments also influenced the delay - but I always knew that I'd come back and write at least the entire associate level exams.

I found this to be the most challenging of all three. I initially thought that this was because I am not a full-time developer but I think beyond that, my personal view, this exam is just hard.

Preparation: AWS CDA

The preparation process was the same, in that I used the exact same resources as for Solutions Architect (full list to be detailed later). I felt like I was not ready throughout my preparations, I was very anxious about writing this exam that I think I may have over-prepared if such a thing exists.

It was amazing to pass the Developer Associate. I also discovered that my motivation had changed. Unlike the AWS CSAA I was already a Cloud Engineer when I wrote the AWS CDA, so the desperation that went with hoping to get a job was no longer there. The desperation was instead replaced by pure curiosity to learn and be better at my job.

AWS Certified SysOps Administrator Associate (AWS CSOA)

I recently wrote and passed the SysOps Administrator exam. I am still torn as to whether this is the hardest versus the Developer exam. What I will say is that I enjoyed preparing for this one the most. There is a huge troubleshooting aspect to this exam, and I enjoy solving problems - maybe the +10 years of production support that I did when I worked on mainframes right at the beginning of my career has something to do with it.
It took time between the Developer exam and this, but once I finally made up my mind that I wanted to write - it took me exactly three weeks to prepare and write.

Preparation: AWS CSOA

The preparation - although there's a lot of material to go through - felt better because a lot of the concepts were no longer new to me.
Also, interesting to note that this was the first exam where I didn't go into absolute surprise at finding out that I've passed. The surprise was this time replaced by a huge realization of how far I've come, I stared at the "PASS" result on the screen for a while, for the first time allowing myself to be proud of my accomplishments.

What's Next?

Associate level done! It feels awesome to say this, to realize it. So what's next? If you remember I wrote CSAA in 2017! Renewal time is fast approaching. I am preparing for this and hoping to write soon.
Once done with this, I will prepare for the Security Specialty - cloud security is an area I'm hugely interested in, and I am looking forward to doing this course.

In closing, I would like to highlight the importance of finding communities that will support your learning and growth. I have been fortunate enough to find these throughout my journey - on various platforms.

While preparing for my CSOA I came across the #100DaysofCloud challenge on LinkedIn/Twitter/Discord and with that I found a group of like-minded and highly supportive people. If you are especially starting out on your cloud journey, join them on Discord - you will find support and be directed to additional/alternative resources that will help you on your journey!

Attending meetups has always been a key part of my learning. Meetups provide spaces to learn from others, they also provide opportunities for one to share with others what they know.
Now that these are currently held online - one can virtually be anywhere where the learning is. Here are a few that I attend:

Also check out the AWS Community Africa on Slack, we discuss all things AWS - and you are welcome to join us even if you are outside of Africa! :)

Resources I used throughout all preparations

1) A Cloud Guru training videos

2) Labs that form part of the training videos

3) AWS White Papers

4) Relevant videos contained in the Amazon Web Services channel on
Youtube

5) Jon Bonso / tutorialsdojo
Practice Exams