DEV Community: Teniola

Building a Weather Dashboard with Python and AWS S3

Teniola — Fri, 24 Jan 2025 10:07:29 +0000

Weather Dashboard

Overview

The Weather Dashboard is a Python-based application designed to fetch real-time weather data for specified cities and store this data in an AWS S3 bucket. It leverages the OpenWeather API for retrieving weather information and uses the Boto3 library to interact with AWS S3, making it a handy tool for anyone who wants to organize and store weather data efficiently.

Features

Fetches real-time weather data for multiple cities
Displays temperature (°F), humidity, and weather conditions
Automatically stores weather data in AWS S3

- Supports multiple cities tracking

Prerequisites

Before you begin, ensure you have the following:

Python 3.6 or higher installed on your system.
An AWS account with S3 access configured.
An OpenWeather API key to fetch weather data.

Installation

1. Clone the Repository

Run the following commands to clone the repository and navigate to its directory:

git clone https://github.com/Teni1023/weather-dashboard.git
cd weather-dashboard

2. Create and Activate a Virtual Environment

Create a virtual environment to manage dependencies:

python -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

3. Install Required Packages

Install the dependencies listed in the requirements.txt file:

pip install -r requirements.txt

4. Configure Environment Variables

Create a .env file in the root directory of the project and add the following environment variables:

OPENWEATHER_API_KEY=your_openweather_api_key
AWS_ACCESS_KEY=your_aws_access_key
AWS_SECRET_KEY=your_aws_secret_key
AWS_REGION=your_aws_region
S3_BUCKET_NAME=your_s3_bucket_name

Replace the placeholders with your actual API keys and AWS details.

Usage

Run the application with the following command:

python src/weather_dashboard.py

The application will fetch weather data for the cities specified in the code.
It will display the weather data in a readable format on the console.
Additionally, the weather data will be saved to your configured AWS S3 bucket.

Code Structure

Here's an overview of the key components of the application:

`weather_dashboard.py`

The main script containing the logic for:

Fetching weather data using the OpenWeather API.
Displaying the data in a user-friendly format.
Saving the data to AWS S3.

Methods

`init()`

Initializes the WeatherDashboard class.
Loads environment variables and sets up configurations.

`create_bucket_if_not_exists()`

Checks if the specified S3 bucket exists.
Creates the bucket if it doesn't exist.

`fetch_weather(city)`

Fetches real-time weather data for the specified city from the OpenWeather API.

`display_weather_data(city, weather_data)`

Displays weather details such as temperature, humidity, wind speed, and weather description in a readable format.

`save_weather_data_to_s3(city, weather_data)`

Saves the fetched weather data to the specified AWS S3 bucket for future reference.

Example Output

Here’s what the output of the application might look like:

Bucket my-weather-bucket exists
Fetching weather for Philadelphia...
Weather data for Philadelphia:
Temperature: 75°F
Weather: clear sky
Humidity: 50%
Wind Speed: 5 mph
Timestamp: 2023-10-01 12:00:00
----------------------------------------
Successfully saved data for Philadelphia to S3

Conclusion

The Weather Dashboard is a simple yet powerful tool for fetching, displaying, and storing weather data. By integrating Python, AWS S3, and the OpenWeather API, this project demonstrates how you can combine various technologies to build a functional and scalable application.

Feel free to clone the repository, explore the code, and customize it to suit your needs.

Deploying Your First Server with Terraform: A Beginner's Guide

Teniola — Tue, 31 Dec 2024 00:07:00 +0000

My name is Tennie, and I began my DevOps journey a few months ago. I am passionate about continuous learning, and I recently joined the Terraform 30-Day Challenge to deepen my understanding and sharpen my skills in infrastructure automation. My goal for this challenge is to become proficient in Terraform, master its concepts and applications, and ultimately achieve certification. For the next 30 days, I will be updating my progress as I take on this exciting learning journey!

Day 3
In this article i will be explaining Deploying Your First Server with Terraform as a beginner

Terraform is a powerful Infrastructure as Code (IaC) tool that allows you to define and provision your infrastructure using declarative configuration files. This guide will walk you through the steps to deploy your first server using Terraform. By the end of this article, you’ll have a basic understanding of how Terraform works and a running server.

Prerequisites

Before you begin, ensure you have the following:

Terraform Installed: Download and install Terraform from Terraform’s official website.

Cloud Provider Account: Create an account with your preferred cloud provider (e.g., AWS

Access Credentials: Set up access credentials for your cloud provider.

Code Editor: Use a code editor like Visual Studio Code.

Step 1: Initialize Your Terraform Project

Create a Project Directory:

mkdir terraform-server-deploy && cd terraform-server-deploy

Write Your First Configuration File:

Create a file named main.tf and open it in your editor. Add the following:

provider "aws" {
region = "us-west-2"
}

resource "aws_instance" "example" {
ami = "ami-0c55b159cbfafe1f0"

instance_type = "t2.micro"

tags = {
Name = "TerraformExampleServer"
}
}

Replace the ami value with an appropriate AMI ID for your region.

Initialize the Directory:
Run the following command to initialize your project:

terraform init

This downloads the necessary provider plugins.

Step 2: Preview and Apply the Configuration

Preview Changes:
Run terraform plan to see what Terraform will create:

terraform plan

Apply the Configuration:
Use the following command to create the server:

terraform apply

Review the proposed changes and type yes to confirm.

Step 3: Verify the Server

Once the terraform apply command completes, you’ll see output with information about the resources created. Use your cloud provider’s console to confirm the instance is running.

Step 4: Clean Up Resources

To avoid unnecessary charges, destroy the resources when you’re done:

terraform destroy

Type yes to confirm the destruction of resources.

Step-by-Step Guide to Setting Up Terraform, AWS CLI, and VS Code

Teniola — Sun, 29 Dec 2024 21:09:58 +0000

Day 2

In this article i will be explaining detailed guide on how to set up Terraform, AWS CLI, and VS Code

Download Terraform

The official Terraform download page: https://www.terraform.io/downloads.

Select the version compatible with your operating system (Windows, macOS, Linux).

Install Terraform

Windows:
Extract the downloaded .zip file.
Move the terraform.exe file to a directory included in your system's PATH, such as C:\Windows\System32.

Verify the installation:


terraform --version

Install AWS CLI

Download AWS CLI

Visit the official AWS CLI download page: https://aws.amazon.com/cli/.

2.1 Install AWS CLI

Windows:
Run the installer and follow the prompts.
Verify the installation:

aws --version

Configure AWS CLI
Run the following command to configure the AWS CLI:


aws configure

Provide:

Access Key ID
Secret Access Key
Default region (e.g., us-east-1)
Output format (e.g., json)

Install Visual Studio Code (VS Code)
3.1 Download and Install VS Code
Download VS Code from: https://code.visualstudio.com/.
Install it by following the prompts for your OS.

3.2 Install Extensions

Open VS Code.

Go to the Extensions Marketplace (Ctrl+Shift+X or Cmd+Shift+X).
Search for and install the following extensions:

What is infrastructure as code and how its transforming DevOps

Teniola — Tue, 24 Dec 2024 01:17:31 +0000

Day 1

In this article i will be explaining what infrastructure as code is and how its transforming DevOps.

What is Infrastructure as Code (IaC)?

Infrastructure as code (IaC) is the ability to provision and support computing infrastructure using code instead of manual processes and settings. Any application environment requires many infrastructure components like operating systems, database connections, and storage. Developers have to regularly set up, update, and maintain the infrastructure to develop, test, and deploy applications.

Manual infrastructure management is time-consuming and prone to error—especially when you manage applications at scale. Infrastructure as code lets you define your infrastructure's desired state without including all the steps to get to that state. It automates infrastructure management so developers can focus on building and improving applications instead of managing environments. Organizations use infrastructure as code to control costs, reduce risks, and respond with speed to new business opportunities.
Infrastructure as Code (IaC) is the practice of managing and provisioning computing infrastructure through machine-readable configuration files, rather than physical hardware configuration or interactive configuration tools. It enables developers and operators to define and manage infrastructure resources.

IaC automates infrastructure deployment and configuration processes, making them consistent, repeatable, and version-controlled

Why IaC is Transforming DevOps

DevOps is the process of improving collaboration between software development and IT operations teams. It aims to shorten the application development lifecycle and provide continuous delivery of high-quality software. DevOps teams integrate operations activities with developer tools and code commits, so applications can have extremely rapid release cycles.

A key goal of DevOps is to automate infrastructure tasks across the development process. You can integrate infrastructure as code (IaC) into continuous integration and continuous deployment (CI/CD) pipelines. This way, when software goes through its build and release process, the necessary infrastructure changes can be made in tandem.

DevOps teams use infrastructure as code for many purposes:

Quickly set up complete environments, from development to production
Help ensure consistently reproducible configurations between environments
Integrate seamlessly with cloud providers and efficiently scale infrastructure resources up or down based on demand
IaC provides a common language for both developers and operations. Changes can be reviewed in a transparent manner, which fosters better collaboration in a DevOps environment.

IaC is revolutionizing DevOps by addressing many challenges associated with traditional infrastructure management. Here's why it's transformative:

Consistency and Standardization

Reduces human errors by automating deployments.
Ensures consistent environments across development, staging, and production.

Speed and Agility

Allows for rapid provisioning and de-provisioning of resources.
Enhances scalability, especially in dynamic environments like cloud computing.

Version Control

IaC configurations are stored as code, making them versionable with tools like Git.
Facilitates auditing, rollback, and collaboration among teams.

Collaboration and Automation

Bridges the gap between developers and operations teams by treating infrastructure the same way as application code.
Integrates seamlessly into CI/CD pipelines, enabling automated testing and deployment.

Cost Efficiency

Minimizes downtime with predictable deployments.
Reduces resource wastage by automating resource cleanup.
Disaster Recovery and Scaling

IaC scripts make it easy to rebuild infrastructure quickly in case of failure.
Supports horizontal and vertical scaling through repeatable configurations.
Real-Life Impact on DevOps
Improved Time-to-Market: Faster environment provisioning leads to quicker deployments.
Error Reduction: Pre-tested, automated configurations eliminate manual errors.
Greater Flexibility: Teams can experiment with different setups without fear of long-term consequences.
IaC is a cornerstone of modern DevOps practices, enabling teams to achieve higher efficiency, reliability, and innovation in software delivery.

Set up SSH Key Authentication

Teniola — Sat, 23 Nov 2024 23:37:19 +0000

Continuing on my DevOps journey, I dove deeper into practical tasks that strengthened my skills in Linux server management, security, and automation. I set up SSH key authentication, secured Nginx with SSL/TLS, and implemented best practices for web server security. Exploring load balancing, I configured Nginx to distribute traffic for high availability. Documenting these steps keeps my journey purposeful and impactful.

Generate an SSH key pair on your local machine:

ssh-keygen -t rsa -b 4096 -C "test2@gmail.com"

Copy the public key to the remote server:

ssh-copy-id user@remote_server_ip

Test the connection:

ssh user@remote_server_ip

Confirm no password is requested.
Disable Password Authentication for SSH:

Open the SSH configuration file on the remote server:

sudo nano /etc/ssh/sshd_config

Modify or add the following lines:
yaml

PasswordAuthentication no
PubkeyAuthentication yes

Restart the SSH service:

sudo systemctl restart sshd

Web Server Security
Enhance Nginx Security with SSL/TLS:

Install Certbot and request a free SSL certificate:

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Verify SSL is working:

https://yourdomain.com

Implement Security Best Practices:

Update Nginx:

sudo apt update && sudo apt upgrade

Set up HTTP to HTTPS redirection:
nginx

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;
    return 301 https://$host$request_uri;
}

Limit buffer size and request rate:
nginx

client_max_body_size 10M;
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=5r/s;

Load Balancing
Basic Load-Balancing Concepts:

Distribute incoming traffic across multiple servers.
Ensure high availability and fault tolerance.
Set Up Nginx as a Simple Load Balancer:

Edit the Nginx configuration file:
nginx

upstream backend {
    server backend1.example.com;
    server backend2.example.com;
}
server {
    listen 80;
    server_name yourdomain.com;
    location / {
        proxy_pass http://backend;
    }
}

Test the configuration:

sudo nginx -t
sudo systemctl reload nginx

Linux Network Configuration

Teniola — Wed, 13 Nov 2024 23:57:46 +0000

A few more steps forward in my DevOps journey! This time, I worked on another task in Linux administration which is focused on configuring server and network settings. In this task, I set a static IP address, configured firewall rules for added security, and installed and set up Nginx to host a simple website. I also explored DNS concepts to understand how domain resolution works. Each step helped solidify the foundational skills necessary for effective system management—a critical part of any DevOps role. Documenting these tasks not only tracks my progress but serves as a practical guide for anyone on a similar path.

This task focuses on configuring essential server and network settings on Linux. Key objectives include assigning a static IP, setting up a firewall for security, installing and configuring Nginx to host a basic website, and learning DNS for domain resolution. Completing this task will build foundational skills in network management, server setup, and security configuration on Ubuntu.

Network Configuration Objective: Configure network settings on a Linux server, assign a static IP address, and troubleshoot network issues with basic tools.

Step 1: Set up a Static IP Address
Identify the Network Interface:

The network interface represents the physical or virtual network adapter through which the system connects to a network.
Use the following command to list all available network interfaces and their current IP addresses:

ip a

Look for your primary interface (often named eth0, enp0s3, or something similar). The IP and subnet mask appear as inet /.
Edit the Network Configuration File:

Ubuntu (using Netplan):
Netplan is the default network configuration utility on recent Ubuntu versions.
Open /etc/netplan/01-netcfg.yaml (the filename may vary in the /etc/netplan/ directory) to configure your network.
Update or add your settings for the desired static IP, gateway, and DNS servers:

network:
  version: 2
  ethernets:
    enp0s3:
      dhcp4: no  # Disables DHCP, which automatically assigns IPs
      addresses:
        - 192.168.1.100/24  # Sets static IP and subnet mask
      gateway4: 192.168.1.1  # Sets the gateway IP for outbound traffic
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4

Save changes and apply them using:

sudo netplan apply

Step 2: Network Troubleshooting

Using ifconfig:

This tool displays network interface configurations (IP addresses, subnet masks, etc.). It’s commonly pre-installed or installable with sudo apt install net-tools.

ifconfig

Using ip:

The ip command provides comprehensive network configuration details and is widely used on modern systems.

ip addr show

Testing Network Connectivity with ping:

Verifies that a remote server is reachable. A successful response means the network is configured and routing correctly.

ping google.com

Firewall Configuration Objective: Set up a firewall to manage incoming and outgoing traffic, limiting access only to necessary services.

Step 1: Install and Configure UFW (Ubuntu)
Install UFW:

UFW (Uncomplicated Firewall) simplifies the management of iptables-based firewall settings.

sudo apt install ufw

Enable UFW:

Activates the firewall. You may need to confirm any prompts.

sudo ufw enable

Allow Traffic for Specific Services:

Allowing specific services like SSH (for remote login) and HTTP/HTTPS (for web services) is crucial. UFW has predefined rules for these services:
SSH:

sudo ufw allow ssh

HTTP (port 80):

sudo ufw allow http

HTTPS (port 443):

sudo ufw allow https

Check Status:

Verifies the current firewall rules.

sudo ufw status

Check Status:

View the active firewall rules and settings:

sudo firewall-cmd --list-all

Install and Configure Nginx Objective: Install the Nginx web server and configure a basic website.

Step 1: Install Nginx
Ubuntu:

sudo apt install nginx

Step 2: Start and Enable Nginx Service
Start Nginx:

Starts the web server, making it active immediately.

sudo systemctl start nginx

Step 3: Configure a Basic HTML Page
Create a Test HTML File:

Place an HTML page in Nginx’s default root directory (/var/www/html/). This will act as the main website.
Create a sample file:

echo "<html><body><h1>My Nginx Server!</h1></body></html>" | sudo tee /var/www/html/index.html

Verify Nginx Setup:

Open a web browser and enter the server’s IP address (e.g., http://192.168.1.100). You should see the "My Nginx Serve!" message if the setup is successful.

Domain Name System (DNS) Objective: Understand DNS basics and configure the system to use specific DNS servers.

Step 1: Basic DNS Concepts
DNS (Domain Name System): Translates domain names (like example.com) to IP addresses.
Resolver: A DNS resolver queries name servers to get IPs for requested domain names.
Name Servers: DNS servers that hold information about domain names and provide IP mappings.
Step 2: Set Up a Local DNS Resolver
Edit the /etc/resolv.conf File:

Configure the system to use specific DNS servers by editing the /etc/resolv.conf file. This example sets Google’s DNS servers:

nameserver 8.8.8.8
nameserver 8.8.4.4

Install and Use dig for DNS Queries:

Ubuntu: Install dnsutils to access dig.

sudo apt install dnsutils

Use dig to check domain resolution:

dig example.com

Step 3: Verify DNS Settings
Use ping to check if the server can resolve domain names, which confirms DNS configuration:

ping google.com

Basic Linux Administration

Teniola — Wed, 13 Nov 2024 00:25:25 +0000

Its few months into my DevOps journey, I've engaged in extensive learning, relearning, and unlearning to build a strong technical foundation. Along the way, I've worked on various tasks and am now documenting my progress to share my learning experience. Here, I present a Basic Linux Administration task I worked on, detailing the foundational skills required for any successful devOps student.

*Introduction *

This article provides a comprehensive overview of essential Linux administration and server configuration tasks, structured to build foundational skills and progress to more advanced topics. The journey begins with Basic Linux Administration, aimed at equipping users with fundamental skills like managing user accounts, file permissions, and package installations. It then transitions to Networking and Web Servers, where users will learn key networking concepts and set up a simple web server. Finally, the guide delves into Advanced Linux Server Configuration, covering deeper configurations and optimizations to enhance server performance and security. Together, these tasks offer a structured pathway for mastering Linux server management.

User Management

Step 1.1: Create and Manage User Accounts

Create a New User

To set up a new user account, the useradd command is used. This creates a user with a default home directory and configuration settings.

sudo groupadd groupname

Set a Password for the New User
After creating the user account, passwd is used to assign a password. This step is critical to ensure security by allowing only authorized access.

sudo passwd username

Step 1.2: Set Up Password Policies

Enforce Password Expiration
To enhance security, password expiration policies are configured using chage. Setting an expiration period ensures that users regularly update their passwords.
with this ,password expires every 90 days

sudo chage -M 90 username

Verify Group Membership
The groups command allows you to verify a user’s group memberships, helping ensure correct permission assignment.

groups username

File System Navigation and Permissions Step 2.1: Navigate the Linux File System Change Directory The cd command allows movement through directories, essential for accessing files and folders within the system.

cd /path/to/directory

List Directory Contents
Using ls -l provides a detailed list of files, including permissions, which is useful for managing and auditing file access.

ls -l

Show Current Directory Path
pwd displays the current directory’s path, which helps verify your location in the file system.

pwd

Step 2.2: Set File and Directory Permissions
Change File Permissions
The chmod command adjusts file permissions (read, write, execute) for the owner, group, and others, crucial for access control.

chmod 755 filename

Change File Ownership
To assign a file to a specific user or group, use chown. This step helps manage ownership, especially in multi-user environments.

sudo chown user:group filename

Check Permissions
Running ls -l filename provides a view of the file’s current permissions, helping confirm the correct settings.

ls -l filename

Package Management Step 3.1: Install Software Using apt (for Ubuntu) To install software on Ubuntu/Debian, first update the package list with apt update and then use apt install to install the package.

sudo apt update
sudo apt install packagename

Step 3.2: Update Software
Using apt
The command apt update && apt upgrade ensures all installed packages are up-to-date.

sudo apt update && sudo apt upgrade

Step 3.3: Remove Software
Using apt
Use apt remove to uninstall unwanted software on Ubuntu.

sudo apt remove packagename

Bash Scripting Step 4.1: Create a Simple Bash Script (user_report.sh) Open a New File Use a text editor like nano or vim to create the script file.

nano user_report.sh

Add the Following Script Content
This script generates a report displaying the number of active users and available disk space.

#!/bin/bash
echo "User Report"
echo "-----------"
echo "Number of users on the system:"
who | wc -l
echo ""
echo "Disk Space Report"
echo "-----------------"
df -h /

Save and Close the Script
Save your changes in the editor. In nano, use CTRL+O to save and CTRL+X to exit.

Step 4.2: Make the Script Executable
Add Execute Permissions
Make the script executable with chmod +x. This allows it to be run directly.

chmod +x user_report.sh

Step 4.3: Run the Script
Execute the Script
Run the script to confirm it displays the user count and disk space information correctly.

./user_report.sh

Set Minimum Password Age
The minimum password age prevents users from changing their passwords too frequently, which can disrupt security protocols

sudo chage -m 1 username

Step 1.3: Manage User Groups
Create a Group
Groups help organize users with similar permissions. To create a new group, use groupadd.

sudo groupadd groupname

Add a User to a Group
Adding a user to a group with usermod grants them the permissions associated with that group, aiding in efficient permission management.

sudo usermod -aG groupname username

Verify Group Membership
The groups command allows you to verify a user’s group memberships, helping ensure correct permission assignment.

groups username

Verify Group Membership
The groups command allows you to verify a user’s group memberships, helping ensure correct permission assignment.

groups username

File System Navigation and Permissions Step 2.1: Navigate the Linux File System Change Directory The cd command allows movement through directories, essential for accessing files and folders within the system.

cd /path/to/directory

List Directory Contents
Using ls -l provides a detailed list of files, including permissions, which is useful for managing and auditing file access.

ls -l

Show Current Directory Path
pwd displays the current directory’s path, which helps verify your location in the file system.

pwd

Step 2.2: Set File and Directory Permissions
Change File Permissions
The chmod command adjusts file permissions (read, write, execute) for the owner, group, and others, crucial for access control.

chmod 755 filename

Change File Ownership
To assign a file to a specific user or group, use chown. This step helps manage ownership, especially in multi-user environments.

sudo chown user:group filename

Check Permissions
Running ls -l filename provides a view of the file’s current permissions, helping confirm the correct settings.

ls -l filename

Package Management Step 3.1: Install Software Using apt (for Ubuntu) To install software on Ubuntu/Debian, first update the package list with apt update and then use apt install to install the package.

sudo apt update
sudo apt install packagename

Step 3.2: Update Software
Using apt
The command apt update && apt upgrade ensures all installed packages are up-to-date.

sudo apt update && sudo apt upgrade

Step 3.3: Remove Software
Using apt
Use apt remove to uninstall unwanted software on Ubuntu.

sudo apt remove packagename

Bash Scripting Step 4.1: Create a Simple Bash Script (user_report.sh) Open a New File Use a text editor like nano or vim to create the script file.

nano user_report.sh

Add the Following Script Content
This script generates a report displaying the number of active users and available disk space.

#!/bin/bash
echo "User Report"
echo "-----------"
echo "Number of users on the system:"
who | wc -l
echo ""
echo "Disk Space Report"
echo "-----------------"
df -h /

Save and Close the Script
Save your changes in the editor. In nano, use CTRL+O to save and CTRL+X to exit.

Step 4.2: Make the Script Executable
Add Execute Permissions
Make the script executable with chmod +x. This allows it to be run directly.

chmod +x user_report.sh

Step 4.3: Run the Script
Execute the Script
Run the script to confirm it displays the user count and disk space information correctly.

./user_report.sh

Linux User Creation Bash Script

Teniola — Wed, 03 Jul 2024 13:55:00 +0000

Introduction

We can use a Bash script to automate the creation of users and groups, set up home directories, generate random passwords, and log all actions.

Script Overview

The script we're going to discuss performs the following functions:

Create Users and Groups: Reads a file containing usernames and group names, creates the users and groups if they do not exist, and assigns users to the specified groups.

Setup Home Directories: Sets up home directories with appropriate permissions and ownership for each user.

Generate Random Passwords: Generates random passwords for the users and stores them securely.

Log Actions: Logs all actions to /var/log/user_management.log for auditing and troubleshooting.

Store Passwords Securely: Stores the generated passwords in /var/secure/user_passwords.csv with restricted access.

The Script

Here is the complete Bash script:

#!/bin/bash

LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.csv"

# Ensure /var/secure exists and has the correct permissions
mkdir -p /var/secure
chmod 700 /var/secure
touch "$PASSWORD_FILE"
chmod 600 "$PASSWORD_FILE"

# Function to log messages
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Function to generate random passwords
generate_password() {
    local password_length=12
    tr -dc A-Za-z0-9 </dev/urandom | head -c $password_length
}

# Function to add users, groups and set up home directories
setup_user() {
    local username=$1
    local groups=$2

    # Create the user
    # &>/dev/null
    if ! id -u "$username" &>/dev/null; then
        password=$(generate_password)
        useradd -m -s /bin/bash "$username"
        echo "$username:$password" | chpasswd
        log_message "User $username created."

        # Store the username and password
        echo "$username,$password" >> "$PASSWORD_FILE"
        log_message "Password for $username stored."
    else
        log_message "User $username already exists."
    fi

    # Create groups and add user to groups
    IFS=',' read -ra group_array <<< "$groups"
    for group in "${group_array[@]}"; do
        if ! getent group "$group" &>/dev/null; then
            groupadd "$group"
            log_message "Group $group created."
        fi
        usermod -aG "$group" "$username"
        log_message "Added $username to $group."
    done
    # Set up the home directory
    local home_dir="/home/$username"
    chown "$username":"$username" "$home_dir"
    chmod 700 "$home_dir"
    log_message "Home directory for $username set up with appropriate permissions."
}

# Main script
if [ $# -eq 0 ]; then
    log_message "Usage: $0 <input_file>"
    exit 1
fi

input_file=$1
log_message "Starting user management script."

# Read the input file and process each line
while IFS=';' read -r username groups; do
    setup_user "$username" "$groups"
done < "$input_file"

log_message "User management script completed."

Logging and Password File Setup

The script ensures that the /var/secure directory exists and has the appropriate permissions.
It creates the password file /var/secure/user_passwords.csv and ensures only the owner can read it.

mkdir -p /var/secure
chmod 700 /var/secure
touch "$PASSWORD_FILE"
chmod 600 "$PASSWORD_FILE"

Message_Log

The log_message function logs messages to /var/log/user_management.log with a timestamp.

log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

password function

The generate_password function generates a random password of a specified length (12 characters in this case).

generate_password() {
    local password_length=12
    tr -dc A-Za-z0-9 </dev/urandom | head -c $password_length
}

User Setup Function

The setup_user function creates users, adds them to groups, sets up home directories with appropriate permissions, and logs each action. It also generates and stores passwords securely.

setup_user() {
    local username=$1
    local groups=$2

    # Create the user
    if ! id -u "$username" &>/dev/null; then
        password=$(generate_password)
        useradd -m -s /bin/bash "$username"
        echo "$username:$password" | chpasswd
        log_message "User $username created."

        # Store the username and password
        echo "$username,$password" >> "$PASSWORD_FILE"
        log_message "Password for $username stored."
    else
        log_message "User $username already exists."
    fi

Main Script

The main part of the script takes an input file as an argument, reads it line by line, and processes each line to create users and groups, set up home directories, and log actions.

if [ $# -eq 0 ]; then
    log_message "Usage: $0 <input_file>"
    exit 1
fi

This makes sure you run the script with an input_file, i.e input.txt

    input_file=$1
    log_message "Starting user management script."

Usage

To use this script, save it to a file (e.g., user_management.sh), make it executable, and run it as a root user with the path to your input file as an argument:

input.txt

    user1;group1,group2
    user2;group3,group4

on the Command Line(CMD) | Terminal

    chmod +x user_management.sh
    ./create_users.sh input.txt

Talents

HNG Internship
HNG Tech

DEV Community: Teniola

Building a Weather Dashboard with Python and AWS S3

Weather Dashboard

Overview

Features

- Supports multiple cities tracking

Prerequisites

Installation

1. Clone the Repository

2. Create and Activate a Virtual Environment

3. Install Required Packages

4. Configure Environment Variables

Usage

Code Structure

weather_dashboard.py

Methods

__init__()

create_bucket_if_not_exists()

fetch_weather(city)

display_weather_data(city, weather_data)

save_weather_data_to_s3(city, weather_data)

Example Output

Conclusion

Deploying Your First Server with Terraform: A Beginner's Guide

Step-by-Step Guide to Setting Up Terraform, AWS CLI, and VS Code

What is infrastructure as code and how its transforming DevOps

Set up SSH Key Authentication

Linux Network Configuration

Basic Linux Administration

Linux User Creation Bash Script

Introduction

Script Overview

The Script

Logging and Password File Setup

Message_Log

password function

User Setup Function

Main Script

This makes sure you run the script with an input_file, i.e input.txt

Usage

`weather_dashboard.py`

`init()`

`create_bucket_if_not_exists()`

`fetch_weather(city)`

`display_weather_data(city, weather_data)`

`save_weather_data_to_s3(city, weather_data)`