DOCSEARCHbyAlgolia
Submit Docs

AndreasBlaze Technical Documentation

website·Indexed 31 days ago

https://andreasblaze.github.io

A comprehensive collection of technical guides and notes covering AWS (S3, EC2, Route 53, Lambda, ELB), Kubernetes (EKS, Helm, OOMKilled troubleshooting), Docker architecture and Compose, Linux system administration, networking tools like nmap and cURL, and Terraform debugging.

Tokens
55.7K
Snippets
210
Records
456
Agent score
72%

What's inside AndreasBlaze Knowledge Base

  1. Overview of Docker Compose

    Docker Compose is a tool for defining and running multi-container Docker applications. It uses a YAML file to configure application services, networks, and volumes, allowing all components to be created and started with a single command.

  2. Overview of Amazon EC2 Core Components

    Amazon EC2 is an Infrastructure as a Service (IaaS) solution consisting of the following primary components:

    • EC2 Instance: The virtual machine itself.
    • EBS Volumes: Virtual disks for data storage.
    • ELB (Elastic Load Balancer): Distributes incoming network traffic across multiple instances.
    • ASG (Auto Scaling Group): Manages the scaling of instance groups.

  3. Overview of Amazon Relational Database Service (RDS)

    Amazon RDS is a managed service for relational databases that use Structured Query Language (SQL). It handles database deployment, patching, backups, and health monitoring, removing the need for manual management on EC2. By default, users cannot connect to RDS instances via SSH. Supported database engines include: Postgres, MySQL, MariaDB, Microsoft SQL Server, IBM DB2, and Aurora (AWS proprietary).

  4. Overview of AWS Database Service Types

    AWS provides a variety of database and storage services categorized by their data model and use case:

    • SQL (RDBMS): RDS, Aurora (ideal for complex joins).
    • NoSQL: DynamoDB (JSON), ElastiCache (key/value), Neptune (graphs), DocumentDB (MongoDB compatible), Keyspaces (Cassandra compatible).
    • Object Store: S3 (large objects), Glacier (archives/backups).
    • Data Warehouse: Redshift (OLAP), Athena, EMR (Analytics/BI).
    • Search: OpenSearch (JSON, free text/unstructured search).
    • Graphs: Amazon Neptune (relationship mapping).
    • Ledger: Amazon Quantum Ledger Database.
    • Time series: Amazon Timestream.

  5. Overview of Btrfs, EFS, NFS, and NTFS

    Other common file systems and protocols include:

    • Btrfs (B-tree File System): Focuses on reliability and scalability. Features include snapshots, multi-device pooling, built-in RAID support, and Copy-on-Write (COW).
    • EFS (Elastic File System): A managed, auto-scaling file storage service for AWS EC2 instances. It has higher latency than local systems like Ext4 or XFS.
    • NFS (Network File System): A distributed protocol that allows network-based file access as if the files were local; used for sharing files across multiple systems.
    • NTFS: The default file system for Windows.

  6. Configure and use DNS A records

    An A record (Address record) maps a domain name to an IPv4 address. It is the most fundamental DNS record type.

    Key details:

    • Root Domain: In configuration files, the @ symbol typically represents the root domain.
    • TTL (Time to Live): Defines how long a record is cached by resolvers before a new lookup is required. The default TTL for A records is often 14,400 seconds (240 minutes).
    • Round Robin Load Balancing: A domain can have multiple A records pointing to different IP addresses to distribute traffic across multiple servers hosting identical content.
    | example.com | record type: | value:    | TTL   |
| ----------- | ------------ | --------- | ----- |
| @           | A            | 192.0.2.1 | 14400 |

  7. Understand the role of Site Reliability Engineering (SRE)

    SRE focuses on maximizing system reliability, scalability, and efficient incident management. Unlike product development, SRE concentrates on how to build and deploy products while maintaining system availability and performance. Key availability metrics include:

    • Response Time: Speed of server response to user requests.
    • Page Load Time: Total time for a page to fully load and render in the browser.
    • Uptime/Downtime: Percentage of time the site is operational.
    • Error Rate: Frequency of errors (e.g., 404, 500).

  8. Understand the Software Development Life Cycle (SDLC) phases

    The Software Development Life Cycle (SDLC) consists of several key stages to ensure software quality and project alignment:

    • Planning: Establishing expectations, defining general goals, estimating costs, and creating a detailed project schedule.
    • Design: Analyzing requirements to determine the best technical solutions, selecting technologies, choosing development tools, and planning integration into existing IT infrastructure.
    • Implementation: Writing the actual code by breaking down requirements into smaller, daily coding tasks.
    • Testing: Using a combination of automated and manual testing to identify bugs and verify that the software meets customer requirements. This often happens in parallel with implementation.
    • Deployment: Moving the final build from a non-production environment (build or test environment) to the production environment. This involves packaging, environment configuration, and installation to ensure zero disruption for end-users.
    • Maintenance: Fixing bugs, resolving customer issues, managing software changes, and monitoring system performance, security, and user experience to identify future improvements.

  9. Interact with the Linux Kernel via the Shell

    The shell acts as an interface that abstracts the internal functions of the kernel from the user. There are two primary types of shells:

    • Command Line Interface (CLI): A text-based interface (typically via a terminal) where users enter specific commands to execute tasks.
    • Graphical User Interface (GUI): A visual interface where users trigger processes through graphical elements, and output is displayed in windows.

  10. Conceptual overview of container isolation and layers

    Containers achieve isolation and resource management through several Linux kernel features:

    • Namespaces: Provide isolation for different system resources, including pid (process isolation), net (network stack), ipc (inter-process communication), and mount (OS mounting).
    • Control Groups (cgroups): Enforce resource limits on containers, such as CPU and memory constraints.
    • UnionFS: Used to create container blocks.
    • Images: Read-Only (RO) templates stored in layers.
    • Containers: An instance of an image with an added writable layer.

  11. Manage user identities with Cognito User Pools

    Cognito User Pools act as a serverless user database for web and mobile apps. They handle user registration, group management, password resets, email/phone verification, MFA, and federated identities (Facebook, Google, SAML). They can be integrated with API Gateway (via token passing) and Application Load Balancer (via listeners and rules).

  12. Connect on-premises data centers to multiple VPCs using AWS Direct Connect

    To connect an on-premises data center to multiple VPCs across different regions, use a Direct Connect Gateway. The architecture involves establishing a Direct Connect connection, creating a private Virtual Interface (VIF) to the Direct Connect Gateway, and then linking that gateway to Virtual Private Gateways (VPG) in each target region via additional private Virtual Interfaces.