This guide will walk you through the steps to claim your is-a.dev subdomain effortlessly.

Why Choose is-a.dev?​

is-a.dev provides free subdomains to developers who want to establish an online presence. It's part of the .dev domain family, known for its Google-backed security and HTTPS enforcement by default.

Key benefits:​

• Professionalism: Perfect for portfolios and technical projects.
• Free for Life: No hidden costs.
• Easy Integration: Works seamlessly with platforms like GitHub Pages, Netlify, or Vercel.

How to Get Your is-a.dev Domain​

Follow these three simple steps to set up your is-a.dev domain:

1. Setting up the Repository​

First, visit the is-a-dev/register repository on GitHub. If you don't already have a GitHub account, sign up here.

Here’s what to do next:

1. Fork and Clone the Register Repository:

• On top corner, you will see fork option button.
• By clicking it, we will create a fork for the register repo.
• Once forked, you can clone the repo by https/ssh.

2. Creating the JSON File​

1. Navigate to the domains folder:

   • In the repository, go to the domains/ folder.
   • Click the Add file button and select Create new file.

2. Name the JSON File:

   • Name the file after the subdomain you want.
   • Example: If you want john-doe.is-a.dev, name your file john-doe.json.

   Naming Requirements:

   • Must be 2–63 characters long.
   • Only dashes (-) are allowed; no underscores (_).
   • Use standard English characters.
     

After naming your file you need to put the JSON content into it, here is an example JSON structure:

3. Add the JSON Content:
   Use this template for your JSON file:

   {
    "description": "Describe the use of this subdomain",
    "repo": "https://github.com/github-username/github-repository",
    "owner": {
        "username": "github-username",
        "email": "[email protected]"
        },
    "record": {
        "CNAME": "github-username.github.io"
        }
    }
   
   • Replace your-github-username with your GitHub username.
   • For RECORDTYPE set it to what you require for your use. You can see the records, in this case I am using my GitHub Page. In your case, you use s3 static hosting url as well.

3. Create your pull request:​

Now you should be greeted with a screen which looks like this:

All you need to do here is fill out the requirements and place an x between the [ ] (so it looks like [x]) for each requirement you meet. Please make sure you meet all the requirements before creating the pull request.

Once you have filled out the requirements you can then click the Create pull request button and you're done!

4. Wait for Approval​

Your pull request will now be reviewed by the maintainers.

• Typical wait time: 12-24 hours (sometimes longer).
• Keep an eye on your PR in case maintainers request changes.

Once merged, your is-a.dev subdomain will be live and ready to use!

Issues with GitHub Pages​

• After the pull request is merged, you may see a 404 error on subdomain.is-a.dev or the wrong site. To fix this, go to your GitHub pages repository's Settings > GitHub pages > Custom Domain and add subdomain.is-a.dev in the given field. Only do this after your pull request is merged.
• Check the Enforce HTTPS checkbox below the custom domain input.
• Wait some time and your site should be live!

In this guide, we’ll walk you through setting up and using SSH keys to manage multiple GitHub accounts effectively. By the end, you'll be able to clone, push, and pull from repositories using the correct account without hassle.

1. Generate Separate SSH Keys for Each Account​

Each GitHub account should have its own SSH key. Follow these steps to generate the keys:

• Primary GitHub account (e.g., for work):

  ssh-keygen -t rsa -b 4096 -C "your_official_email@example.com" -f ~/.ssh/github-primary
  

• Secondary GitHub account (e.g., personal):

  ssh-keygen -t rsa -b 4096 -C "your_personal_email@example.com" -f ~/.ssh/github-personal
  

This creates two key pairs:

• ~/.ssh/github-primary and ~/.ssh/github-primary.pub
• ~/.ssh/github-personal and ~/.ssh/github-personal.pub

2. Add SSH Keys to the SSH Agent​

To ensure the keys are readily available for use, add them to the SSH agent:

ssh-add ~/.ssh/github-primary
ssh-add ~/.ssh/github-personal

3. Configure the SSH Config File​

The SSH configuration file (~/.ssh/config) allows you to map specific SSH keys to different GitHub accounts. Open or create the file:

nano ~/.ssh/config

Add the following entries:

# Primary GitHub Account (Work)
Host github-primary
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-primary

# Secondary GitHub Account (Personal)
Host github-secondary
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-personal

Save the file and exit. These aliases (github-primary and github-secondary) will let you specify which SSH key to use when interacting with GitHub.

4. Add Public Keys to GitHub Accounts​

Each SSH key has a corresponding public key (.pub file). Add these to your respective GitHub accounts:

• Copy the public key for your primary account:

  cat ~/.ssh/github-primary.pub
  

• Copy the public key for your secondary account:

  cat ~/.ssh/github-personal.pub
  

Log in to GitHub and navigate to Settings > SSH and GPG keys > New SSH Key. Paste the public key and give it a recognizable title.

5. Clone Repositories Using Specific Accounts​

When cloning repositories, use the host alias specified in the SSH config file:

• For your primary account:

  git clone git@github-primary:organization/repository.git
  

• For your secondary account:

  git clone git@github-secondary:username/repository.git
  

By specifying github-primary or github-secondary, Git automatically uses the correct SSH key.

6. Update Remote URLs for Existing Repositories​

Important If you've already cloned a repository but want to switch to a specific account, update the remote URL:

1. Navigate to the repository:

   cd repository-name
   

2. Update the remote URL:

   git remote set-url origin git@github-primary:organization/repository.git
   

3. Verify the remote URL:

   git remote -v
   

7. Test Your Setup​

To confirm everything is configured correctly, test the SSH connection for each account:

• Primary account:

  ssh -T git@github-primary
  

• Secondary account:

  ssh -T git@github-secondary
  

If the setup is correct, you’ll see a message like:

Hi <username>! You've successfully authenticated, but GitHub does not provide shell access.

Conclusion​

Managing multiple GitHub accounts doesn't have to be complicated. By configuring SSH keys and using a well-structured ~/.ssh/config file, you can easily switch between accounts and ensure you're always using the right credentials for the task at hand.

Have questions or run into issues? Feel free to connect, and I’ll be happy to help!