Deploy Website on Custom Domain with GitHub Copilot CLI

🚀 Project Showcase: Terraform MariaDB Deployment on AWS I'm excited to share one of my recent DevOps projects where I automated the deployment of Development and Staging MariaDB environments on AWS using Infrastructure as Code (IaC). 🔹 Project Highlights ✅ Provisioned AWS infrastructure using Terraform ✅ Configured VPC, Public Subnet, Internet Gateway, Route Table, and Security Groups ✅ Launched an Ubuntu EC2 instance ✅ Automated server provisioning using user_data (Shell Script) ✅ Installed Docker and Docker Compose automatically ✅ Deployed two independent MariaDB containers: Development Environment Staging Environment ✅ Created reusable SQL scripts for: Database Schema Role-Based Access Control (RBAC) Users & Permissions ✅ Implemented least-privilege access with separate database roles ✅ Configured Docker Volumes for persistent database storage ✅ Verified remote database connectivity and performed CRUD operations successfully 🛠️ Technologies Used AWS EC2 Terraform Docker & Docker Compose Ubuntu Linux MariaDB SQL Shell Scripting Git & GitHub 📚 What I Learned This project helped me gain hands-on experience with: ✔ Infrastructure as Code (Terraform) ✔ AWS Networking ✔ Linux Server Automation ✔ Docker Containerization ✔ Database Administration ✔ Role-Based Access Control (RBAC) ✔ DevOps Automation & Best Practices 📂 GitHub Repository 🔗 Repository: https://lnkd.in/d7NfN_Uc I would greatly appreciate your feedback and suggestions. I'm continuously learning and building more projects in AWS Cloud and DevOps. Thank you for taking the time to read my post! 😊 #AWS #Terraform #Docker #MariaDB #Linux #DevOps #InfrastructureAsCode #CloudComputing #GitHub #AWSCloud #SQL #CloudEngineer #DevOpsEngineer #OpenToWork

𝗢𝗽𝗲𝗻𝗶𝗻𝗴 𝗮 𝗿𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 𝘂𝘀𝗲𝗱 𝘁𝗼 𝗺𝗲𝗮𝗻 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝗰𝗼𝗱𝗲. 𝗖𝗵𝗮𝗶𝗻𝗗𝗿𝗼𝗽 𝘁𝘂𝗿𝗻𝗲𝗱 𝗶𝘁 𝗶𝗻𝘁𝗼 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻. ChainDrop is an ongoing software supply-chain campaign. It steals developer and CI/CD credentials, then uses them to compromise more packages and repositories. In samples analyzed by Pillar, the attackers planted a Claude Code SessionStart hook and a VS Code folderOpen task inside compromised repositories. Depending on the tool and its trust settings, starting a Claude Code agent could launch the payload, before the first prompt and without waiting for npm install. The loader downloaded Bun and ran an obfuscated credential harvester targeting GitHub and npm tokens, cloud credentials, SSH keys, and secrets held in GitHub Actions runner memory. An npm preinstall hook covered package consumers through a third execution path. This is living off the agent harness. The attacker doesn’t need to convince the model to do anything. The repository supplies the instruction, and the developer’s trusted tools supply the identity and authority. Agent and repository config that runs commands is code. Secure it before it runs, not after. 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗳𝘂𝗹𝗹 𝗖𝗵𝗮𝗶𝗻𝗗𝗿𝗼𝗽 𝗮𝗻𝗮𝗹𝘆𝘀𝗶𝘀: https://lnkd.in/dx78v3h3

Another day, another Github outage. Five hours in. https://lnkd.in/dDcDDqyU -=- We are continuing to work on an issue affecting GitHub Actions. Webhook triggers are currently throttled to help with recovery and and we are processing approximately 15% of webhooks, so many events such as pushes and pull requests are not triggering workflow runs. Of jobs queued, approximately 65% are succeeding, improved from a low of 30 to 40% earlier in this incident. -=- So...you're not really recovered. Processing 15% of webhooks means GHA based CI/CD is dead in the water. There's also no guidance on whether webhooks that didn't run are queued or failed. Evidence is that they are failed, not queued...I had several CI workflows that had random individual actions that just failed with an internal error. I don't want to create load - or pay- for a redundant run. But when you're waiting on a build to get real work done, it's hard to sit. GHAs are amazing and have given me a solid, turnkey CI that's better than anything I've built to date. It's great that I'm not managing my own security hole, I mean build server. But - it's pretty much all in on the infrastructure. For those of us on Github Cloud - that ship has sailed...but it doesn't mean that I'm not interested...and looking at what is coming next.

I was tasked with writing a simple GitHub Action: build an image and push it to ghcr. The image was built, but pushing to ghcr was denied: not authorized. After eight hours of asking Claude WTF was the problem and doing the suggested fixes, like repeatedly creating fine-grained and classic Personal Access Tokens with read/write permissions, yatta, yatta. I finally found the solution by searching and reading GitHub issues. I was pushing to a repository that I had created with a Docker push. Deleting the existing image allowed the action to push the image. There was nothing wrong with the action, just a quirk of the repository. This reminds me of a TikTok in which a Gen Alpha asked how people could drive anywhere without Google Maps or GPS. The responses made me laugh because quite a few folks said they printed MapQuest maps. It dawned on me that we are several generations past, where no one knows how to read a map or knows about atlases such as Key Maps. It's apparent that we will soon have the first generation of people who won't know how to read stack traces, dig through the source code, or search and read through issues.

After two months of work, GitBack is finally ready. 🎉 This project started with a personal problem. Most GitHub backup services are built for teams and enterprises. They often charge per repository, per user, or based on storage usage. Those services absolutely have their place, but I wanted something different something built for individuals who simply want to own their backups. So I built GitBack. What started as a simple GitHub backup utility evolved into a production-ready github resourse backup tool designed around a few core principles: • Simplicity – easy to set up and operate. • Transparency – no hidden magic, just predictable behavior. • Reliability – built to run unattended with data integrity in mind. • Observability – structured logging and health reporting for complete visibility. Some of the features include: 📦 Local-first backups 📁 Backup GitHub repositories and Gists 🔄 Incremental mirror synchronization ❤️ Health checks and integrity validation 📝 Audit-friendly logs, easy to ingest into monitoring systems and LLM workflows ⚙️ Designed to run unattended in production environments Rebuilding GitBack from ground up after 2-3 years has been a great experience. Designing reliable systems, making thoughtful architectural decisions, and keeping operational simplicity at the center of the project. I'm excited to finally share it with the community, and I hope others find it useful for protecting their GitHub data. Feedback, issues, and contributions are always welcome.

I have 33 public repos on GitHub. The one that gets the least attention is the one I use the most. DarkContext is a self-hosted MCP server for LLM memory. SQLite and sqlite-vec under the hood, no vendor in the loop, runs on your own machine. I built it because I kept running into the same problem across every agent setup I tried. Two tools write to the same memory store. One overwrites what the other just learned. Your agent loses context it had ten minutes ago, and you don't even notice until something downstream breaks quietly. The fix wasn't complicated in concept. Each tool gets its own memory scope. Cursor doesn't clobber what Claude Code wrote. The test runner doesn't leak into the agent drafting your docs. But nobody was building this, because scoped memory is boring infrastructure. It's not a model improvement. It's not a new UI. It's plumbing. So I built the plumbing. It's TypeScript, MIT licensed, and it runs on a $20/month VPS if you want it off your laptop. No API keys to a memory vendor, no data leaving your network. I'm not sure yet whether this is a project ten people care about or ten thousand. But every week I use it, I find another case where isolated memory is the difference between an agent that works and one that silently drifts. Shipping the boring part anyway.

To whom has copilot seat but no api key My case is bit special: we have enterprise github copilot seats but no api key to directly call AI models. How to run some cron tasks with AI on jenkins? I can manually kick off copilot in command line with my personal github token, which starts with ghp_***, but when do the same thing with jenkins job, it denied: Error: Classic Personal Access Tokens (ghp_) are not supported by Copilot. The COPILOT_GITHUB_TOKEN environment variable contains a classic PAT. Please use a Fine-Grained Personal Access Token or another authentication method. To fix this, you can: • Replace the token in COPILOT_GITHUB_TOKEN with a fine-grained PAT • Unset COPILOT_GITHUB_TOKEN and run 'gh auth login' to authenticate • Unset COPILOT_GITHUB_TOKEN and start 'copilot', then use the '/login' command First thought: set my linkin status to “OPEN TO WORK” ? The workaround stop me doing above: Step 1 — mint the OAuth token (one-time, on a machine with a browser) Log in as the same account that has the Copilot seat : gh auth login # GitHub.com → HTTPS → "Login with a web browser" gh auth token # prints gho_xxxxxxxx ← copy this The gho_ token is what makes your manual runs work. Step 2 — store it in Jenkins Add a new Secret text credential, e.g. id copilot.oauth.token, with the gho_... value. Now, you can use copilot cli in your jenkins job.

A secret deleted from a GitHub repository's current branch is not gone. It stays retrievable through commit history, unless the owner has rewritten that history and force-pushed it, something most projects never do. GitHub indexes the entire commit history for full-text search, not just the live branch. Old API keys, internal hostnames and other exposed data can resurface long after a "cleanup" commit removes them from view. Even a deleted or private repository isn't always gone. A fork created before that happened keeps the full history alive independently, and cached search results can keep surfacing a repository for a while after it disappears. Attribution needs care too. Commit author emails are frequently real, personal or corporate addresses, even behind a pseudonymous handle, though git lets anyone set that field locally with no verification. A systematic pass across code, history, forks and contributor metadata turns these traces into a reliable picture of what a target has actually exposed. In this guide we cover the full method: scoping the search, recovering secrets from commit history, pivoting from a contributor account to a real identity, and checking findings against the false positives that trip this work up. Link in comments.

You leave a comment on a GitHub pull request. You click Comment. The button spins and nothing appears, so you click it again. Now your comment is sitting on that PR twice. That is a double-fire, and you caused it. Not "a system somewhere might." You, probably this week. So here is the real question: was that GitHub's bug, or does your own code have the same hole? Most people cannot answer that about the code they shipped last week. "Idempotent" gets thrown around like it is obvious. It is not. It is a specific, testable property, and most code fails the test the first time anyone actually runs it. The test itself is simple enough to run in your head. Take any write your API makes. Run it twice. Ask one question: does the world look the same as it did after running it once? Same? Idempotent. Different? It is not, no matter what the code comments claim. Most writes fail this quietly, not loudly. An endpoint that inserts a fresh row on every call is the easy case. You will see the duplicate row the same way you saw the duplicate comment. The dangerous ones do not look wrong on the surface. A "mark as read" that increments an unread counter instead of setting a flag. A "like" that appends to a list instead of checking if you are already on it. A signup confirmation that fires a new email every time the client retries, instead of checking whether one already went out. Call each of those twice. The counter is off by one. The list has a duplicate entry. The user has two identical emails and no idea why. Nothing crashed. Nothing threw an error. The system just quietly drifted from what actually happened. The free course at systemthinkinglab.ai/learn walks the seven building blocks through exactly this question: a Queue redelivering a job it already handed out, a Service taking the same request twice, and what each one has to survive. You do not know a system is idempotent because the code looks clean. You know it because you ran it twice and looked.

I just published a plugin for Claude Code: github-issue-picker It has been a huge help in my daily workflow and can help anyone who, like me, is building their own SaaS solo or is working in any small project with the support of AI. You run /pick-issue, Claude lists a GitHub repository's open issues, you pick one and it implements it. It reads the full issue (body + comments), implements the change in your worktree, and references the issue in the commit and PR — once you allow it — so the issue gets closed when the PR is merged. 🔧 Single requirement: GitHub CLI (gh) installed and authenticated. All interaction with GitHub happens exclusively through it — no extra connections. By design, what it does NOT do (that's up to the user): ❌ Manage GitHub tokens; ❌ Commit, push, or open a PR without your confirmation; ❌ Close or comment on issues; To install it, go to Code -> Customize -> Plugins -> Add -> Add Marketplace -> Add from a repository 👉 https://lnkd.in/dy_9dkj7 Open source (MIT). Feedback is welcome! #ClaudeCode #AI #DeveloperTools #GitHub #SaaS #OpenSource