This repository is a full-stack marketing demo application powered by Google Cloud generative AI (Vertex AI Gemini, Imagen). It provides an end-to-end workflow for generating campaign content (emails, social media posts, website copy, images), analyzing audiences via natural language to BigQuery, and managing assets across platforms. The frontend is a modern Angular 17 single-page application with Firebase authentication and hosting, while the backend is a FastAPI Python service deployed on Cloud Run. Terraform infrastructure-as-code provisions all GCP resources including BigQuery datasets, Vertex AI Search datastores, Dialogflow CX agents, and Google Drive folder templates for content export. The application showcases marketing use cases like trendspotting via GDELT news summarization, audience insights using structured and unstructured data, and interactive image editing with inpainting/outpainting. While primarily a demo application, the repository also contains several Jupyter notebooks exploring model tuning, text-to-SQL, and clustering explanations, making it a hybrid resource for both application developers and data scientists.
This repository implements a Terraform provider for managing Incus, a container and virtual machine orchestration platform. It provides full CRUD operations for Incus resources such as instances, networks, storage pools, profiles, projects, certificates, cluster groups, and server configuration, along with corresponding data sources for reading existing state. The provider is built using the Terraform Plugin Framework (v1.19.0) with some fallback to Plugin SDK v2, and communicates with Incus via its client library (github.com/lxc/incus/v7). Key entry points include the main.go provider server, internal/provider/provider.go for resource registration, and individual resource files under internal/{certificate,cluster,image,instance,network,profile,project,server,storage}. The provider supports multiple remotes, OIDC authentication, clustering, and PKI, and includes a code generation tool (cmd/generate-datasources) that produces consistent data source implementations and documentation from a YAML configuration and Go templates. Acceptance tests require a live Incus environment and cover complex scenarios like instance lifecycle, exec triggers, file uploads, and import. The codebase is well-structured with shared utilities in internal/common for config/device/file/import handling, and demonstrates a consistent pattern for state synchronization and error handling. However, it carries some technical debt from its fork of the LXD provider, including dual SDK usage and heavy boilerplate that could benefit from further abstraction.
Digger (now OpenTaco) is an infrastructure-as-code orchestration platform that automates Terraform, OpenTofu, Terragrunt, and Pulumi workflows within existing CI/CD pipelines. The system provides PR-level automation (plan/apply comments), drift detection, policy-as-code via OPA, and an optional Terraform Enterprise-compatible state management and remote execution layer. It integrates with GitHub, GitLab, Bitbucket, Azure DevOps, and Buildkite through webhooks and CI backends. The architecture is a multi-service monorepo: a Go backend (Gin/GORM) handles webhooks, job scheduling, and a web UI; a separate CLI tool (cobra) runs directly in CI; a drift detection service with cron scheduling; a sandbox sidecar (TypeScript/Node) for remote execution; and the Taco service (Echo) that reimplements TFE APIs for state management, RBAC, and run execution. The UI is a React/TanStack Router app with WorkOS authentication. The codebase is actively maintained with frequent releases, extensive SQL migrations, Helm charts for Kubernetes deployment, and dual open-core and enterprise (ee/) feature sets.
This repository is the operational backbone for Bazel's continuous integration system. It orchestrates Buildkite pipelines for hundreds of Bazel projects (including Bazel itself, rules repositories, and downstream projects like TensorFlow), manages cloud infrastructure on Google Cloud Platform (GCE, GCR, Cloud SQL, BigQuery), and provides a suite of tools for release management, cherry-picking, metrics collection, and a monitoring dashboard. The architecture is polyglot: a Rust agent uploads test artifacts from Build Event Protocol files, a Go service collects and publishes pipeline performance metrics, a Spring Boot backend with a Next.js frontend serves a dashboard for tracking GitHub issues and build stats, and Python scripts (primarily `bazelci.py`) handle dynamic pipeline generation and CI orchestration. Infrastructure is managed via Terraform, with GitHub Actions for automated PR review of the Bazel Central Registry and release workflows. The codebase is actively maintained but shows signs of technical drift, including hardcoded versions, references to end-of-life platforms, and a large number of manually defined pipelines that risk configuration drift.
This repository provides Terraform modules for managing Google Cloud SQL instances (MySQL, PostgreSQL, SQL Server) with features including backups, high availability, private networking, IAM authentication, and encryption. It follows a modular architecture where each database type and supporting feature (backup, restore, private service access) is implemented as a separate, reusable Terraform module. The root module is deprecated in favor of direct use of the submodules. Key entry points are the module directories (modules/mysql, modules/postgresql, etc.) and the examples directory which contains ready-to-run configurations for common deployment patterns. The system automates database lifecycle management through infrastructure-as-code, integrating with Google Cloud services like Cloud Workflows for backup scheduling, KMS for encryption, and Service Networking for private access. While the modules are well-maintained with frequent updates and comprehensive documentation, they exhibit tight coupling to Google Cloud-specific services and Terraform provider versions, limiting portability outside the GCP ecosystem.
This repository contains a full-stack web application deployed on AWS ECS with a CI/CD pipeline. The frontend is a Vue.js application that retrieves product data from a backend Node.js/Express API. The backend scans a DynamoDB table and returns product information, including image URLs stored in S3. Infrastructure is provisioned via Terraform, including networking, ECS cluster/services, ECR repositories, IAM roles, CodePipeline/CodeBuild/CodeDeploy for Blue/Green deployments, autoscaling, and supporting resources (S3, DynamoDB, SNS). The architecture separates concerns with modular Terraform modules and implements production-grade practices like health checks, Swagger documentation, and stress testing.
This is a Terraform module for deploying a production-grade HashiCorp Vault cluster on Google Compute Engine (GCE). It provisions all necessary networking (VPC, subnets, NAT, firewalls), a GCS bucket for Vault's storage backend, a KMS key for auto-unseal and TLS encryption, and manages the full lifecycle of Vault nodes via a managed instance group with autoscaling and autohealing. The module supports both internal and external load balancers, and includes an optional submodule (`modules/cluster`) for organizations that need to separate concerns (e.g., shared VPC setups). The core logic resides in the `modules/cluster` submodule, which contains instance templates, load balancer configuration, health checks, IAM bindings, and self-signed TLS certificate generation. A startup script template handles Vault installation, configuration, mTLS setup, logging agents, and security hardening (core dumps disabled, swap disabled, unprivileged user). The module is highly parameterized with ~60 input variables, allowing customization of machine types, Vault versions, networking, and TLS management. It is designed for high availability (HA) with GCS backend and auto-unseal via Cloud KMS. The repository includes examples, integration tests using Kitchen/Terraform and Inspec, and CI/CD pipelines, indicating a mature, community-maintained module. The code is clean and follows Google's Cloud Foundation Toolkit conventions, but it is relatively conventional Terraform infrastructure code, not particularly novel or reusable beyond its intended purpose.
This repository is a large collection of tutorial lessons (numbered 006 to 281) focused on DevOps, cloud infrastructure, and backend development. It contains example applications in multiple languages (Go, Rust, Python, Node.js, Java, etc.) demonstrating common patterns like CRUD APIs, database integration, caching, and monitoring. The infrastructure-as-code examples cover Kubernetes (deployments, RBAC, ingress, service meshes), Terraform (AWS, GCP, Azure), Ansible, Helm, and CI/CD with ArgoCD. A significant portion is dedicated to observability with Prometheus, Grafana, and custom exporters. The repository serves as a companion to video tutorials and is not a single production application but a learning resource. It exhibits high duplication across lessons and some pseudo-code, but contains several reusable components for monitoring, infrastructure provisioning, and performance benchmarking.
This repository is a large collection of ~41 independent DevOps learning projects, each demonstrating a specific technology stack or pipeline (e.g., CI/CD with Jenkins, infrastructure as code with Terraform, containerization with Docker, orchestration with Kubernetes on AWS/Azure). It is not a single application but a portfolio of deployable demo applications (Java Spring PetClinic, Netflix clone, Swiggy clone, Chatbot UI, etc.) coupled with infrastructure code and step-by-step tutorials. The code quality varies widely across projects; many are boilerplate or copied from other tutorials, but a few components exhibit good craftsmanship, such as the OneToManyResultSetExtractor in PetClinic and the import/export utility in Chatbot UI. The repository serves as a learning resource rather than a production system, and its primary value lies in the breadth of DevOps tooling coverage rather than in reusable software components.
This repository is a personal portfolio and link aggregation page for Anton Babenko, a well-known figure in the Terraform and AWS DevOps community. It contains no source code, application logic, or data pipelines. The sole content is a README.md file that lists links to the author's social media profiles, media projects (YouTube channel, newsletter), major open-source projects (terraform-aws-modules, pre-commit-terraform, serverless.tf, compliance.tf), utilities, and abandoned projects. It serves as a central directory for discovering the author's work, but it is not a functional software repository. There are no executable files, tests, configuration files, or any code that can be run or reused. The repository is essentially a static documentation page with no technical depth.