BuzzerboyAWSLightsail 0.329.1__py3-none-any.whl

BuzzerboyAWSLightsailStack/LightsailDatabase.py

@@ -0,0 +1,405 @@
+"""
+AWS Lightsail Database Infrastructure Stack
+==========================================
+
+This module provides a specialized AWS Lightsail database deployment stack
+using CDKTF (Cloud Development Kit for Terraform) with Python.
+
+The stack includes:
+    * Lightsail Database instance (PostgreSQL)
+    * Multiple databases within the instance
+    * Individual database users with scoped permissions
+    * Secrets Manager for credential storage per database
+    * IAM resources for service access
+
+:author: Generated with GitHub Copilot
+:version: 1.0.0
+:license: MIT
+"""
+
+#region specific imports
+
+import os
+import json
+from enum import Enum
+from constructs import Construct
+from cdktf import TerraformOutput
+
+# Import the base class
+from .LightsailBase import LightsailBase, BaseLightsailArchitectureFlags
+
+#endregion
+
+#region AWS Provider and Resources
+from cdktf_cdktf_provider_aws import (
+    lightsail_database,
+)
+#endregion
+
+#region Random Provider and Resources
+from cdktf_cdktf_provider_random import password
+
+#endregion
+
+#region ArchitectureFlags 
+class ArchitectureFlags(BaseLightsailArchitectureFlags):
+    """
+    Architecture configuration flags for optional components.
+
+    Extends BaseLightsailArchitectureFlags with database-specific flags.
+
+    :param SKIP_DATABASE_USERS: Skip creating individual database users (use master user only)
+    """
+
+    SKIP_DATABASE_USERS = "skip_database_users"
+
+#endregion
+
+
+class LightsailDatabaseStack(LightsailBase):
+    """
+    AWS Lightsail Database Infrastructure Stack.
+
+    A comprehensive database stack that deploys:
+        * Lightsail Database instance with PostgreSQL
+        * Multiple databases within the instance
+        * Individual database users with scoped permissions
+        * Secrets Manager for storing all database credentials
+        * IAM resources for programmatic access
+
+    :param scope: The construct scope
+    :param id: The construct ID
+    :param kwargs: Configuration parameters including databases array
+
+    Example:
+        >>> stack = LightsailDatabaseStack(
+        ...     app, "my-db-stack",
+        ...     region="ca-central-1",
+        ...     project_name="my-app",
+        ...     databases=["app_db", "analytics_db", "logs_db"],
+        ...     postApplyScripts=[
+        ...         "echo 'Database deployment completed'",
+        ...         "psql -h $DB_HOST -U master -d postgres -c '\\l'"
+        ...     ]
+        ... )
+    """
+
+    @staticmethod
+    def get_architecture_flags():
+        """
+        Get the ArchitectureFlags enum for configuration.
+
+        :returns: ArchitectureFlags enum class
+        :rtype: type[ArchitectureFlags]
+        """
+        return ArchitectureFlags
+
+    def __init__(self, scope, id, **kwargs):
+        """
+        Initialize the AWS Lightsail Database Infrastructure Stack.
+
+        :param scope: The construct scope
+        :param id: Unique identifier for this stack
+        :param kwargs: Configuration parameters
+
+        **Configuration Parameters:**
+
+        :param region: AWS region (default: "us-east-1")
+        :param environment: Environment name (default: "dev")
+        :param project_name: Project identifier (default: "bb-aws-lightsail-db")
+        :param databases: List of database names to create (required)
+        :param flags: List of ArchitectureFlags to modify behavior
+        :param profile: AWS profile to use (default: "default")
+        :param postApplyScripts: List of shell commands to execute after deployment
+        :param secret_name: Custom secret name (default: "{project_name}/{environment}/database-credentials")
+        :param db_instance_size: Database instance size (default: "micro_2_0")
+        :param db_engine: Database engine version (default: "postgres_14")
+        :param master_username: Master database username (default: "dbmasteruser")
+        """
+        # Set database-specific defaults
+        if "project_name" not in kwargs:
+            kwargs["project_name"] = "bb-aws-lightsail-db"
+        if "secret_name" not in kwargs:
+            project_name = kwargs["project_name"]
+            environment = kwargs.get("environment", "dev")
+            kwargs["secret_name"] = f"{project_name}/{environment}/database-credentials"
+        
+        # Call parent constructor
+        super().__init__(scope, id, **kwargs)
+
+        # ===== Database-Specific Configuration =====
+        self.databases = kwargs.get("databases", [])
+
+        # Validate required parameters
+        if not self.databases:
+            raise ValueError("The 'databases' parameter is required and must contain at least one database name")
+
+        # ===== Database Configuration =====
+        self.master_username = kwargs.get("master_username", "dbmasteruser")
+        self.db_instance_size = kwargs.get("db_instance_size", "micro_2_0")
+        self.db_engine = kwargs.get("db_engine", "postgres_14")
+
+        # ===== Internal State =====
+        self.database_users = {}
+        self.database_passwords = {}
+
+    def _set_default_post_apply_scripts(self):
+        """
+        Set default post-apply scripts specific to database deployments.
+        """
+        # Call parent method for base scripts
+        super()._set_default_post_apply_scripts()
+
+        # Skip if flag is set
+        if BaseLightsailArchitectureFlags.SKIP_DEFAULT_POST_APPLY_SCRIPTS.value in self.flags:
+            return
+
+        # Add database-specific scripts before the final message
+        databases_list = ", ".join(self.databases)
+        database_scripts = [
+            f"echo '️  Database Instance: {self.project_name}-db'",
+            f"echo '📊 Databases Created: {databases_list}'",
+            f"echo '👥 Database Users: {len(self.databases)} individual users created'",
+            "echo '🔗 Connection Information:'",
+            "echo '   - Instance Endpoint: Available in Terraform outputs'",
+            f"echo '   - Master User: {self.master_username}'",
+            "echo '   - Port: 5432 (PostgreSQL)'",
+            "echo '   - Credentials: Stored in AWS Secrets Manager'",
+        ]
+
+        # Insert database-specific scripts before the final "execution started" message
+        if self.post_apply_scripts:
+            # Find the index of the last script and insert before it
+            insert_index = len(self.post_apply_scripts) - 1
+            for script in reversed(database_scripts):
+                self.post_apply_scripts.insert(insert_index, script)
+
+    def create_lightsail_resources(self):
+        """
+        Create Lightsail-specific resources for database deployment.
+
+        Creates:
+            * Database passwords for master and individual users
+            * Lightsail PostgreSQL database instance
+            * Individual database user credentials (for later manual creation)
+        """
+        # Generate passwords first
+        self.create_database_passwords()
+        
+        # Create the database instance
+        self.create_lightsail_database()
+        
+        # Prepare database user credentials
+        self.create_database_users()
+
+    def create_database_passwords(self):
+        """
+        Generate secure passwords for master user and individual database users.
+
+        Creates:
+            * Master database password for the instance
+            * Individual passwords for each database user
+            * Stores passwords in internal dictionaries for later use
+        """
+        # Master database password
+        self.master_password = password.Password(
+            self, "master_db_password", 
+            length=20, 
+            special=True, 
+            override_special="!#$%&*()-_=+[]{}<>:?"
+        )
+
+        # Individual database user passwords
+        for db_name in self.databases:
+            db_password = password.Password(
+                self, f"{db_name}_user_password",
+                length=16,
+                special=True,
+                override_special="!#$%&*()-_=+[]{}<>:?"
+            )
+            self.database_passwords[db_name] = db_password
+
+    def create_lightsail_database(self):
+        """
+        Create Lightsail PostgreSQL database instance.
+
+        Creates a PostgreSQL database instance with the specified configuration.
+        The instance will host multiple databases as specified in the databases parameter.
+
+        Database Configuration:
+            * Engine: PostgreSQL (version specified by db_engine)
+            * Size: Configurable (default: micro_2_0)
+            * Master database: Uses first database name from the list
+            * Final snapshot: Disabled (skip_final_snapshot=True)
+        """
+        # Use the first database name as the master database name
+        master_db_name = self.clean_hyphens(self.databases[0])
+
+        self.database = lightsail_database.LightsailDatabase(
+            self,
+            "database_instance",
+            relational_database_name=f"{self.project_name}-db",
+            blueprint_id=self.db_engine,
+            bundle_id=self.db_instance_size,
+            master_database_name=master_db_name,
+            master_username=self.master_username,
+            master_password=self.master_password.result,
+            skip_final_snapshot=True,
+            tags={
+                "Environment": self.environment, 
+                "Project": self.project_name, 
+                "Stack": self.__class__.__name__,
+                "DatabaseCount": str(len(self.databases))
+            },
+        )
+
+        # Store database instance in resources registry
+        self.resources["lightsail_database"] = self.database
+
+        # Populate master credentials in secrets
+        self.secrets.update({
+            "master_username": self.master_username,
+            "master_password": self.master_password.result,
+            "master_database": master_db_name,
+            "host": self.database.master_endpoint_address,
+            "port": self.database.master_endpoint_port,
+            "engine": self.db_engine,
+            "region": self.region
+        })
+
+    def create_database_users(self):
+        """
+        Prepare database user credentials for individual databases.
+
+        This method creates credentials for individual database users that would be
+        created manually or via external scripts after deployment. For each database 
+        in the databases list, it will:
+            1. Generate a password for the database user
+            2. Store credentials in the secrets dictionary
+            3. Create user information for reference
+
+        **Manual Database Setup Required:**
+        After deployment, you'll need to manually create databases and users:
+            * CREATE DATABASE {db_name};
+            * CREATE USER "{db_name}-dbuser" WITH PASSWORD '{password}';
+            * GRANT ALL PRIVILEGES ON DATABASE {db_name} TO "{db_name}-dbuser";
+
+        .. note::
+           Database and user creation happens manually after deployment since
+           Lightsail doesn't provide Terraform resources for individual databases.
+        """
+        if ArchitectureFlags.SKIP_DATABASE_USERS.value in self.flags:
+            return
+
+        for db_name in self.databases:
+            clean_db_name = self.clean_hyphens(db_name)
+            username = f"{clean_db_name}-dbuser"
+            password_ref = self.database_passwords[db_name].result
+            
+            # Store user credentials in secrets
+            self.secrets[f"{clean_db_name}_username"] = username
+            self.secrets[f"{clean_db_name}_password"] = password_ref
+            self.secrets[f"{clean_db_name}_database"] = clean_db_name
+            
+            # Store in database_users for reference
+            self.database_users[clean_db_name] = {
+                "username": username,
+                "password": password_ref,
+                "database": clean_db_name
+            }
+
+        # Add manual setup instructions to post-terraform messages
+        if self.databases and not self.has_flag(ArchitectureFlags.SKIP_DATABASE_USERS.value):
+            setup_commands = []
+            for db_name in self.databases:
+                clean_db_name = self.clean_hyphens(db_name)
+                username = f"{clean_db_name}-dbuser"
+                setup_commands.extend([
+                    f"CREATE DATABASE IF NOT EXISTS \"{clean_db_name}\";",
+                    f"CREATE USER \"{username}\" WITH PASSWORD '<password_from_secrets>';",
+                    f"GRANT ALL PRIVILEGES ON DATABASE \"{clean_db_name}\" TO \"{username}\";"
+                ])
+            
+            self.post_terraform_messages.append(
+                f"Manual database setup required. Connect to the database instance and run:\n" +
+                "\n".join(setup_commands)
+            )
+
+    def create_outputs(self):
+        """
+        Create Terraform outputs for important resource information.
+
+        Generates outputs for:
+            * Database instance endpoint
+            * Master database credentials (sensitive)
+            * Individual database credentials (sensitive)
+            * IAM access keys (sensitive)
+            * Database list and connection information
+
+        .. note::
+           Sensitive outputs are marked as such and will be hidden in
+           Terraform output unless explicitly requested.
+        """
+        # Database instance outputs
+        TerraformOutput(
+            self,
+            "database_endpoint",
+            value=f"{self.database.master_endpoint_address}:{self.database.master_endpoint_port}",
+            description="Database instance connection endpoint",
+        )
+
+        TerraformOutput(
+            self,
+            "database_instance_name",
+            value=self.database.relational_database_name,
+            description="Lightsail database instance name",
+        )
+
+        # Master credentials (sensitive)
+        TerraformOutput(
+            self,
+            "master_username",
+            value=self.master_username,
+            description="Master database username",
+        )
+
+        TerraformOutput(
+            self,
+            "master_password",
+            value=self.master_password.result,
+            sensitive=True,
+            description="Master database password (sensitive)",
+        )
+
+        # Database list
+        TerraformOutput(
+            self,
+            "databases_created",
+            value=json.dumps(self.databases),
+            description="List of databases created in the instance",
+        )
+
+        # Individual database credentials (sensitive)
+        if not self.has_flag(ArchitectureFlags.SKIP_DATABASE_USERS.value):
+            for db_name in self.databases:
+                clean_name = self.clean_hyphens(db_name)
+                if clean_name in self.database_users:
+                    user_info = self.database_users[clean_name]
+                    
+                    TerraformOutput(
+                        self,
+                        f"{clean_name}_username",
+                        value=user_info["username"],
+                        description=f"Database user for {clean_name}",
+                    )
+
+                    TerraformOutput(
+                        self,
+                        f"{clean_name}_password",
+                        value=user_info["password"],
+                        sensitive=True,
+                        description=f"Database password for {clean_name} (sensitive)",
+                    )
+
+        # Use the shared IAM output helper
+        self.create_iam_outputs()

buzzerboyawslightsail-0.329.1.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: BuzzerboyAWSLightsail
+Version: 0.329.1
+Summary: Buzzerboy Architecture for Deploying Web Applications on AWS LightSail
+Home-page: https://www.buzzerboy.com/
+Author: Buzzerboy Inc
+Author-email: Buzzerboy Inc <info@buzzerboy.com>
+Project-URL: Homepage, https://www.buzzerboy.com/
+Project-URL: Issues, https://dev.azure.com/buzzerboyinc/buzzerboy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: cdktf<1.0,>=0.17.0
+Requires-Dist: constructs<11.0,>=10.0.0
+Requires-Dist: cdktf-cdktf-provider-aws>=12.0.0
+Requires-Dist: cdktf-cdktf-provider-random>=8.0.0
+Requires-Dist: toml
+Requires-Dist: pipenv
+Requires-Dist: boto3>=1.26.0
+Requires-Dist: botocore>=1.29.0
+Requires-Dist: BuzzerboyArchetype
+Requires-Dist: AWSArchitectureBase
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# AWS Infrastructure with CDKTF (Python)
+
+This project uses the **Cloud Development Kit for Terraform (CDKTF)** with **Python** to define and deploy AWS infrastructure using named AWS profiles via `~/.aws/credentials` and `~/.aws/config`.
+
+---
+
+## ✅ Prerequisites
+
+### 1. Install Required Tools
+
+Make sure the following tools are installed:
+
+* **Node.js** (v16 or later)
+* **npm**
+* **Terraform CLI**
+* **Python 3.7+**
+* **AWS CLI**
+
+#### macOS Example:
+
+```bash
+brew install node
+brew install terraform
+brew install python
+brew install awscli
+```
+
+### 2. Install CDKTF CLI
+
+```bash
+npm install -g cdktf-cli
+```
+
+### 3a. Configure AWS CLI (Option 1 - Use AWS Provided Tooling)
+
+```bash
+aws configure --profile myprofile
+```
+
+This creates or updates the following files:
+
+`~/.aws/credentials`:
+
+```ini
+[myprofile]
+aws_access_key_id=YOUR_ACCESS_KEY
+aws_secret_access_key=YOUR_SECRET_KEY
+```
+
+`~/.aws/config`:
+
+```ini
+[profile myprofile]
+region=us-west-2
+output=json
+```
+
+
+### 3b. Configure AWS CLI (Option 2 - Use Open Source AWS Login - Recommended)
+
+
+#### 3b - 1. Clone the code repo from Fahad Zain Jawaid
+```bash
+git clone https://github.com/fahadzainjawaid/awsIdentityTools
+```
+
+You can follow the ReadMe on the repo above to get latest usage and setup guides.
+
+---
+
+## 🚀 Getting Started
+
+### 1. Install the package
+
+```bash
+pip install pip install BBAWSLightsailMiniV1a
+```
+
+### 2. Set Up Python Environment & Install Dependencies
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+export PIPENV_VERBOSITY=-1
+pip install -r requirements.txt
+```
+
+### 3. Install AWS Provider Bindings
+
+```bash
+cdktf get
+```
+
+### 4. Synthesize Terraform Configuration
+
+```bash
+cdktf synth
+```
+
+### 5. Review the Plan
+
+```bash
+cdktf plan
+```
+
+### 6. Deploy the Infrastructure
+
+```bash
+cdktf deploy
+```
+
+### 7. Destroy the Infrastructure (if needed)
+
+```bash
+cdktf destroy
+```
+
+## 🛠 Useful Commands
+
+| Command         | Description                     |
+| --------------- | ------------------------------- |
+| `cdktf get`     | Install provider bindings       |
+| `cdktf synth`   | Generate Terraform JSON config  |
+| `cdktf plan`    | Preview planned changes         |
+| `cdktf deploy`  | Deploy infrastructure to AWS    |
+| `cdktf destroy` | Destroy deployed infrastructure |
+
+---
+
+## 📁 .gitignore Suggestions
+
+```gitignore
+.venv/
+cdktf.out/
+.terraform/
+__pycache__/
+*.pyc
+```
+
+---
+
+## 📝 Notes
+
+* To install additional Python packages:
+
+  ```bash
+  pip install <package>
+  pip freeze > requirements.txt
+  ```
+
+* To suppress pipenv verbosity in environments where pipenv is used:
+
+  ```bash
+  export PIPENV_VERBOSITY=-1
+  ```
+
+---
+
+## 📚 References
+
+* [CDK for Terraform Documentation](https://developer.hashicorp.com/terraform/cdktf)
+* [AWS Provider Docs](https://registry.terraform.io/providers/hashicorp/aws/latest/docs)

buzzerboyawslightsail-0.329.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+BuzzerboyAWSLightsailStack/LightSailPostDeploy.py,sha256=uOEOe5qORPgvivC0Ba0w045PQztfS6z-ynwyikaPQzI,5025
+BuzzerboyAWSLightsailStack/LightsailAIContainer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+BuzzerboyAWSLightsailStack/LightsailBase.py,sha256=YfQrFNHvdWxGgpgy1A2CgAD2R5fz_ebQyVaADZaxCPw,25946
+BuzzerboyAWSLightsailStack/LightsailContainer.py,sha256=_PvA5fMFEHdlI-jATcDTOAOs6R0MHwBj5Hjudh4SMxI,13314
+BuzzerboyAWSLightsailStack/LightsailDatabase.py,sha256=hffRjVbYADV7SK5cD4orwt0etb-pTDxtQvEv58iQyyI,15425
+BuzzerboyAWSLightsailStack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+buzzerboyawslightsail-0.329.1.dist-info/METADATA,sha256=CXKk9RZiVbGDaQksYC_7spEH2HqjlK5I2-ORAbpdPj4,3839
+buzzerboyawslightsail-0.329.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+buzzerboyawslightsail-0.329.1.dist-info/top_level.txt,sha256=xqYoH36d7_13q4vRi5bZr1zIz9mR7b8ms_6ez3BqRgQ,27
+buzzerboyawslightsail-0.329.1.dist-info/RECORD,,

buzzerboyawslightsail-0.329.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

buzzerboyawslightsail-0.329.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+BuzzerboyAWSLightsailStack