Skip to content

Instantly share code, notes, and snippets.

@Nilpo
Last active April 26, 2024 19:09
Show Gist options
  • Save Nilpo/8ed5e44be00d6cf21f22 to your computer and use it in GitHub Desktop.
Save Nilpo/8ed5e44be00d6cf21f22 to your computer and use it in GitHub Desktop.
Using Git to Manage a Live Web Site

Using Git to Manage a Live Web Site

Overview

As a freelancer, I build a lot of web sites. That's a lot of code changes to track. Thankfully, a Git-enabled workflow with proper branching makes short work of project tracking. I can easily see development features in branches as well as a snapshot of the sites' production code. A nice addition to that workflow is that ability to use Git to push updates to any of the various sites I work on while committing changes.

Contents

Prerequisites

  • Git, installed on both the development machine and the live server
  • a basic working knowledge of Git, beginners welcome!
  • passwordless SSH access to your server using pre-shared keys
  • a hobby (you'll have a lot of extra time on your hands with the quicker workflow)

back to top


Getting Started

Installing Git

Git is available for Windows, Linux, and Mac. Getting it installed and running is a pretty straightforward task. Check out the following link for updated instructions on getting Git up and running.

Getting Started Installing Git

You'll need to have Git installed on your development machines as well as on the server or servers where you wish to host your website. This process can even be adapted to work with multiple servers such as mirrors behind a load balancer.

back to top

Setting up Passwordless SSH Access

The process for updating a live web server relies on the use of post hooks within the Git environment. Since this is fully automated, there is no opportunity to enter login credentials while establishing the SSH connection to the remote server. To work around this, we are going to set up passwordless SSH access. To begin, you will need to SSH into your server.

ssh user@hostname

Next, you'll need to make sure you have a ~/.ssh in your user's home directory. If not, go ahead and create one now.

mkdir ~/.ssh

On Mac and Linux, you can harness the power of terminal to do both in one go.

if [ ! -d ~/.ssh ]; then mkdir ~/.ssh; fi

Next you'll need to generate a public SSH key if you don't already have one. List the files in your ~/.ssh directory to check.

ls -al ~/.ssh

The file you're looking for is usually named similarly to id_rsa.pub or id_ed25519. If you're not sure, you can generate a new one. The command below will create an SSH key using the provided email as a label.

ssh-keygen -t ed25519 -C "your_email@example.com"

You'll probably want to keep all of the default settings. This will should create a file named id_ed25519 in the ~/.ssh directory created earlier.

When prompted, be sure to provide a secure SSH passphrase.

If you had to create an SSH key, you'll need to configure the ssh-agent program to use it.

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

If you know what you are doing, you can use an existing SSH key in your ~/.ssh directory by providing the private key file to ssh-agent.

If you're still not sure what's going on, you should two files in your ~/.ssh directory that correspond to the private and public key files. Typically, the public key will be a file by the same name with a .pub extension added. An example would be a private key file named id_ed25519 and a public key file named id_ed25519.pub.

Once you have generated an SSH key on your local machine, it's time to put the matching shared key file on the server.

ssh-copy-id -i ~/.ssh/id_ed25519.pub user@hostname

This will add your public key to the authorized keys on the remote server. This process can be repeated from each development machine to add as many authorized keys as necessary to the server. You'll know you did it correctly when you close your connection and reconnect without being prompted for a password.

back to top


Configuring the Remote Server Repository

The machine you intend to use as a live production server needs to have a Git repository that can write to an appropriate web-accessible directory. The Git metadata (the .git directory) does not need to be in a web-accessible location. Instead, it can be anywhere that is user-writeable by your SSH user.

back to top

Setting up a Bare Repository

In order to push files to your web server, you'll need to have a copy of your repository on your web server. You'll want to start by creating a bare repository to house your web site. The repository should be set up somewhere outside of your web root. We'll instruct Git where to put the actual files later. Once you decide on a location for your repository, the following commands will create the bare repository.

git init --bare --shared mywebsite.git && cd $_

A bare repository contains all of the Git metadata without any HEAD. Essentially, this means that your repository has a .git directory, but does not have any working files checked out. The next step is to create a Git hook that will check out those files any time you instruct it to.

If you wish to run git commands from the detached work tree, you'll need to set the environmental variable GIT_DIR to the path of mywebsite.git before running any commands.

back to top

Add a Post-Receive Hook

Create a file named post-receive in the hooks directory of your repository with the following contents. You may optionally specify a branch name to checkout. If unspecified, the default master or main branch is used.

#! /bin/sh
GIT_WORK_TREE=/path/to/webroot/of/mywebsite git checkout -qf [--detach] [<branch>]

Once you create your hook, go ahead and mark it as executable.

chmod +x hooks/post-receive

GIT_WORK_TREE allows you to instruct Git where the working directory should be for a repository. This allows you to keep the repository outside of the web root with a detached work tree in a web accessible location. Make sure the path you specify exists, Git will not create it for you.

back to top


Configuring the Local Development Machine

The local development machine will house the web site repository. Relevant files will be copied to the live server whenever you choose to push those changes. This means you should keep a working copy of the repository on your development machine. You could also employ the use of any centralized repository including cloud-based ones such as GitHub or BitBucket. Your workflow is entirely up to you. Since all changes are pushed from the local repository, this process is not affected by how you choose to handle your project.

back to top

Setting up the Working Repository

On your development machine, you should have a working Git repository. If not, you can create one in an existing project directory with the following commands.

git init
git add -A
git commit -m "Initial Commit"

back to top

Add a Remote Repository Pointing to the Web Server

Once you have a working repository, you'll need to add a remote pointing to the one you set up on your server.

git remote add live ssh://server1.example.com/home/user/mywebsite.git

Make sure the hostname and path you provide point to the server and repository you set up previously. If your remote user name is different from that of your local machine, you'll need to modify the above command to include the remote user name.

git remote add live ssh://user@server1.example.com/home/user/mywebsite.git

Finally, it's time to push your current website to the live server for the first time.

git push live +master:refs/heads/master

This command instructs Git to push the current master branch to the live remote. (There's no need to send any other branches.) In the future, the server will only check out from the master branch so you won't need to specify that explicitly every time.

back to top


Build Something Beautiful

Everything is ready to go. It's time to let the creative juices flow! Your workflow doesn't need to change at all. Whenever you are ready, pushing changes to the live web server is as simple as running the following command.

git push live

Setting receive.denycurrentbranch to "ignore" on the server eliminates a warning issued by recent versions of Git when you push an update to a checked-out branch on the server.

If you ever need to force a reload on the server side without making any local changes, simply create an empty commit and push it!

git commit --allow-empty -m "trigger update"
git push live

back to top


Additional Tips

Here are a few more tips and tricks that you may find useful when employing this style of workflow.

back to top

Pushing Changes to Multiple Servers

You may find the need to push to multiple servers. Perhaps you have multiple testing servers or your live site is mirrored across multiple servers behind a load balancer. In any case, pushing to multiple servers is as easy as adding more urls to the [remote "live"] section in .git/config.

[remote "live"]
    url = ssh://server1.example.com/home/user/mywebsite.git
	url = ssh://server2.example.com/home/user/mywebsite.git

Now issuing the command git push live will update all of the urls you've added at one time. Simple!

back to top

Ignoring Local Changes to Tracked Files

From time to time you'll find there are files you want to track in your repository but don't wish to have changed every time you update your website. A good example would be configuration files in your web site that have settings specific to the server the site is on. Pushing updates to your site would ordinarily overwrite these files with whatever version of the file lives on your development machine. Preventing this is easy. SSH into the remote server and navigate into the Git repository. Enter the following command, listing each file you wish to ignore.

git update-index --assume-unchanged <file...>

This instruct Gits to ignore any changes to the specified files with any future checkouts. You can reverse this effect on one or more files any time you deem necessary.

git update-index --no-assume-unchanged <file...>

If you want to see a list of ignored files, that's easy too.

git ls-files -v | grep ^[a-z]

back to top


References

@dzianis-bocharov
Copy link

dzianis-bocharov commented May 15, 2021

I have used "#! /bin/sh" with space inside instead of "#!/bin/sh" , because in my case it first showed mistake for hook : "no such file or directory", spent alot hours to understand this, thanks for your post :-)

@Nilpo
Copy link
Author

Nilpo commented May 16, 2021

If some files are deleted directly in the web server, git push live will not replace/update it.

Is there a way to do a forced git push live which will re-upload files? (even if there is no local changes on the local computer)

Just create an empty commit and push!

git commit --allow-empty -m "trigger update"     <--- creates a commit without adding any changed files
git push live

@Nilpo
Copy link
Author

Nilpo commented May 16, 2021

I have used "#! /bin/sh" with space inside instead of "#!/bin/sh" , because in my case it first showed mistake for hook : "no such file or directory", spent alot hours to understand this, thanks for your post :-)

Spaces in the shebang line are strictly optional. This really shouldn't cause a problem. I'll add the space, but I'm curious what system you are working with.

@Nilpo
Copy link
Author

Nilpo commented May 16, 2021

I would replace

ssh` user@hostname 'cat >> ~/.ssh/authorized_keys' < ~/.ssh/id_rsa.pub

with

ssh-copy-id -i ~/.ssh/id_rsa.pub user@hostname

I originally used ssh-copy-id but I removed it for compatibility reasons. It doesn't exist on every system. It's definitely good to use it on systems that support it!

@Nilpo
Copy link
Author

Nilpo commented May 16, 2021

Well, every repo needs a base branch; "main" is the default on GitHub since October 2020. Anyone creating a new repo will get that as their base branch. Since these instructions are hosted on GitHub, they would be more complete if they indicated that and told the user to either change their base branch to "master" in their repo settings (and, of course, either rename or create a "master" branch) or alter the setup described here to use "main".

I may update this on the next major edit. Frankly, it's not strictly necessary and the Git binary still uses master. Github still works with master as well. GH has actually made it more confusing that necessary.

We're not creating the repo on Github, it's created locally if you follow the instructions so GH won't care either.

I have added this to my list of things to address though. Thanks for the suggestion.

@rodneytamblyn
Copy link

Can someone extend this GIST to explain how to set file ownership and permissions on files in the post-receive hook? Assume for example that ssh session is root, but files need to be deployed in web user.

@rodneytamblyn
Copy link

Further to my question, my solution (I don't know if this is the best, but it seems to work)
su -c "GIT_WORK_TREE=/PATH/WEBSITE git checkout -f" web
... where 'web' in this case is the user I want the files to be owned by.

To get this solution working you may need to change existing ownership and file permissions of the bare repository to allow the web user to read, as otherwise it will generate permissions errors, as you are "su" to the context of "web" user.
so for example:
chown root:web /path/to/barerepo.git
chown root:web /path/to/website
... and chmod the file permissions.

Works for me, but there may be better ways - please advise if you know them.

@barnamah
Copy link

barnamah commented Oct 6, 2021

After the first step which I created bare repository /home/xyz/example.com.git
git init --bare --shared

now what should I do ? I can't believe there is no tutorial anywhere on the web to make it work.
my web directory is located /home/www/example.com/
how can I use git? Actually what is the next step?

  1. Should copy files from /home/www/example.com/ to /home/xyz/example.com.git
  2. or there is a command get files from /home/www/example.com/

Year after year (may be 10 years now) I realize git is important but always find problem and give up.

@Nilpo
Copy link
Author

Nilpo commented Oct 7, 2021

After the first step which I created bare repository /home/xyz/example.com.git git init --bare --shared

now what should I do ? I can't believe there is no tutorial anywhere on the web to make it work. my web directory is located /home/www/example.com/ how can I use git? Actually what is the next step?

  1. Should copy files from /home/www/example.com/ to /home/xyz/example.com.git
  2. or there is a command get files from /home/www/example.com/

Year after year (may be 10 years now) I realize git is important but always find problem and give up.

If you have an existing web site, these instructions won't work for you easily. You should make a local copy of all of the web site files on your local PC. Then you should empty the web site directory on the server and follow these instructions. With a post-hook in place, you can return to your local PC and commit the web site files to your repository. This will push them back up to your server where they belong.

However, if you do not use Git, I strongly recommend that exercise caution before attempting this. You may want to consider not trying it at all. If you do this incorrectly there is a risk of losing data since your server directory is not empty to begin with.

Git can be complicated, but it's basic functions can be quite simple. I suggest checking out a good tutorial or YouTube video. 20 minutes of practice on a clean project and you will be up and running. You can set up a local web server and test all of this from your local machine before attempting this on a production server.

@Nilpo
Copy link
Author

Nilpo commented Oct 7, 2021

Maybe I should do a YouTube video demoing all of this.

@barnamah
Copy link

barnamah commented Oct 7, 2021

@Nilpo thank you for your reply. you still used terms that is not clear "post-hook". use simple words. if you are making a video then title should be "How to use Gig with existing website contents" and do not assume anything that the user know. I am creating tutorials on YouTube but when see tutorial on Git, they none can work in my case. They are all vague or they assume user knows stuff.
May be my understanding is wrong about git.
I assume that Git is a tool that I modify a file, it keeps the older file for me and I can check it any time to see what changes I have done. But no one explains how to use if efficiently. If Git does not or cannot upload the modified file to my live folder then why should I use Git? I can make copy of the file, edit it and use it. if I want to compare them later, I can use Notepad++ to compare two files or texts.

I gave up again.

@Nilpo
Copy link
Author

Nilpo commented Oct 8, 2021

@Nilpo thank you for your reply. you still used terms that is not clear "post-hook". use simple words. if you are making a video then title should be "How to use Gig with existing website contents" and do not assume anything that the user know. I am creating tutorials on YouTube but when see tutorial on Git, they none can work in my case. They are all vague or they assume user knows stuff. May be my understanding is wrong about git. I assume that Git is a tool that I modify a file, it keeps the older file for me and I can check it any time to see what changes I have done. But no one explains how to use if efficiently. If Git does not or cannot upload the modified file to my live folder then why should I use Git? I can make copy of the file, edit it and use it. if I want to compare them later, I can use Notepad++ to compare two files or texts.

I gave up again.

Git can do everything you've said.

Everything you need is step-by-step in the instructions. You should be able to follow it even if you've never used Git before. The instruction show how to set up the Post-Receive hook. This tells Git what to do wherever you commit new changes to your project folder.

I'm sorry that you are giving up, but all of the information you need to make this work is here. It's written for beginners.

@YungCrunchy
Copy link

YungCrunchy commented Mar 2, 2022

@Nilpo Hi Niplo, hope you are well and thank you for your tutorial. I have been getting an error on the "git push live +main:refs/heads/main" step. how can I approach this? it is initialized as shared

[local ~] git push live +main:refs/heads/main

fatal: '/example.git' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

@Nilpo
Copy link
Author

Nilpo commented Mar 25, 2022

Git is always a saving grace, but I don't think your server should be the host. Should anything happen to the server you're losing too much. I think a service like GitHub or its competitors should be the host.

You're absolutely right. The server isn't the central repository (although it acts like one). Just add another remote to your project and push changes to GitHub or whatever central repository you choose to use. You can even push them all simultaneously as I show later in the post.

@Nilpo
Copy link
Author

Nilpo commented Mar 25, 2022

@Nilpo Hi Niplo, hope you are well and thank you for your tutorial. I have been getting an error on the "git push live +main:refs/heads/main" step. how can I approach this? it is initialized as shared

[local ~] git push live +main:refs/heads/main

fatal: '/example.git' does not appear to be a git repository fatal: Could not read from remote repository.

Please make sure you have the correct access rights and the repository exists.

It sounds like you aren't using the correct repository name in your project. The origin setting in your project must match the name of the *.git directory on the server. Have a look at the output from git remote -v show. In your case, it's probably showing example.git (based on your error) but the repository on your server was actually named something different. Perhaps the name of your site or domain.

@vigilancetech-com
Copy link

I've tried to follow these instructions as closely as possible but when I get to the git push to populate the web server's git repo it says everything is okay but the actual index.html file doesn't copy across.

Any idea how to debug this?

@hansgv
Copy link

hansgv commented Sep 27, 2022

@Nilpo Is it possible to revert to the previous version in case there's an issue after git push live?

@Nilpo
Copy link
Author

Nilpo commented Sep 27, 2022

@Nilpo Is it possible to revert to the previous version in case there's an issue after git push live?

Sure. Just make any corrections locally and make a new commit or simply roll the pointer back to an earlier commit using any of git's history commands and then push live again. The live server will always pull the latest commit on the master branch. If you need more control, you can implement other branching methodologies, but the practice remains the same.

You can also point the live server to any commit you wish by modifying the line used in the tutorial.

 git push live +master:refs/heads/master

But this is an advanced concept and it can lead to unexpected results if you aren't careful. You're better off leaving your master branch (or whatever branch you choose) as a "production" branch and ensuring that is last commit is always a working state. Feature branch, test build, and merge working states into that branch. Rolling back a single commit should always return your application to a working state if anything goes wrong.

@rodneytamblyn
Copy link

You can also push a specific commit hash to remote like this (where deploy is the post-receive hook):

git push -f staging eb26cxxxxxxxx9da265577633xxxxxxx543:deploy

Works for me, but I am not an expert. Nilpo's best practice advice above is good.

@Nilpo
Copy link
Author

Nilpo commented Sep 28, 2022

You can also push a specific commit hash to remote like this (where deploy is the post-receive hook):

git push -f staging eb26cxxxxxxxx9da265577633xxxxxxx543:deploy

Works for me, but I am not an expert. Nilpo's best practice advice above is good.

You're absolutely right. I keep my recommendations as simple as possible since it's so hard to provide support here. But you are spot on. This can be expanded as far as your individual skill level will allow. My own implementation is a bit more complex as well, especially where production sites are concerned.

@Nilpo
Copy link
Author

Nilpo commented Sep 28, 2022

I've tried to follow these instructions as closely as possible but when I get to the git push to populate the web server's git repo it says everything is okay but the actual index.html file doesn't copy across.

Any idea how to debug this?

Git has a --verbose option for some commands that may help, but it's hard to say without getting an idea what your set up looks like. My first thougths would be to make sure your users have adequate permissions for the directories you are working with. You can also do a clone of your repo to your local machine or another server to test for any issues within the repo. If you've done any copy/pasting maybe you've gotten some non-printable characters and Git is choking on that. Otherwise, the only real issues I've run into were either permission-based or network problems.

@Nilpo
Copy link
Author

Nilpo commented Sep 28, 2022

Further to my question, my solution (I don't know if this is the best, but it seems to work) su -c "GIT_WORK_TREE=/PATH/WEBSITE git checkout -f" web ... where 'web' in this case is the user I want the files to be owned by.

To get this solution working you may need to change existing ownership and file permissions of the bare repository to allow the web user to read, as otherwise it will generate permissions errors, as you are "su" to the context of "web" user. so for example: chown root:web /path/to/barerepo.git chown root:web /path/to/website ... and chmod the file permissions.

Works for me, but there may be better ways - please advise if you know them.

Sorry I missed getting back to this. This is certainly a viable option. Although, it would be my preference to not run this as a root user an rely on su to take care of things. Privilege de-escalation is generally bad practice. We generally want to operate as exactly the correct user with no more permissions than is absolutely required. For me, that would mean allowing ssh for the web user temporarily and setting this up as that user. All files would then be owned by web without any hassles.

Of course you could set this up as root and do a chown -R web .git/.

Either way, after your initial pull to the server, the Post-Receive hook should always run as the web user anyway, especially if you are chrooted or otherwise sandboxed as with most typical server setups.

We would never want Git to make arbitrary changes to a server with root privileges. Especially since we're allowing it to execute a shell script essentially unattended.

@jenetiks
Copy link

jenetiks commented Dec 7, 2022

Could we update the keygen to utilize a stronger algorithm, such as ed25519? While RSA is sufficient for now, ed25519 is considered to be quantum resistant and better practice.

Either way, thank you for your contributions! Guides for newbies are always a good thing!

@Nilpo
Copy link
Author

Nilpo commented Dec 8, 2022

Could we update the keygen to utilize a stronger algorithm, such as ed25519?

Done! Thanks for the suggestion. The current recommendation is to use certficates instead of keys, but the process is much more involved so I've been putting off. The goal was to keep this beginner-friendly, and certificates woud definitely move this into an intermediate or advanced setup although it really is the most secure, especially if this system is used with multiple servers at once. Maybe I'll fork this and do both.

@Kwpa
Copy link

Kwpa commented Feb 6, 2023

Thanks for these instructions! I was wondering if the following is possible using your technique (I may have misunderstood some things):

  1. Set up any kind of static blog site (in my case I'd be using 11ty) with a 'posts' folder
  2. In a separate private Github repo create .md files
  3. Some .md files would be tagged in frontmatter as 'private', others 'public'
  4. Push changes to the repo
  5. Have the website connect to the Github account via SSH
  6. Update the 'posts' folder with only the .md files that are tagged 'public'
  7. Render those files into the static site as appropriate

Do your instructions cover this?

@Denis5161
Copy link

Hello,

this gist is amazing. I set it up on my server and it runs perfectly. I also have a .gitignore file in my repo, which I remove with rm <#PATH>/.gitignore.

Thank you!
Is there maybe an official command to checkout a working tree to another path? I have tried git checkout-index, but that doesn't work because it's a post-receive hook.

@minifiredragon
Copy link

minifiredragon commented Mar 12, 2023

Just getting into git myself atm, and as a side note, I use a self hosted gitlab instance and the instructions had me init the repository using main instead of master. So when I ran the

git push live +master:refs/heads/master

This of course led to nothing happing but an error message, and it took me some time to track down that the above line is what did it. Even though I re ran the line as

git push live +main:refs/heads/main

It never updated the HEAD file and nothing worked. I did some minor searches on how to fix this with a git command, but did not really find any way to fix it. So the short answer was I edited the HEAD file and changed master to main, and at that point all worked well.

If you could add a note to that particular section that master should be the name of the top branch (what ever the proper term is) it might help us newbs keep a little more hair. :)

@dwesolowski
Copy link

Kinda follow what needs to be done but I will be using a centralized repository (github)

Goals:

  1. Develop on one machine
  2. Push to Github
  3. Github push changes to my webserver IP?

Could you give a little guidance here?

@hayden-t
Copy link

hayden-t commented May 17, 2023

Could you give a little guidance here?

Hi, Time for an update on my method, I first wound up here too, when i had the idea to use git on live website. It works great, I still use it, and also connect to github for privately storing the code.

The key thing I do differently to how this guide recommends and how i started out, is to keep your git repo (.git folder) one level above the public_html folder. This way there is no chance of it accidentally becoming exposed and publicly accessible. (which has happened to me twice by accident)

The trick is to use .gitignore to ignore all and then add back the dirs you want, (most likely public_html, maybe more)

/*
!/public_html
!/.gitignore

then you can have github as a remote, and use the deploy key setting for the repo to allow you/others to push/pull from the live and dev website copies, and collaborate with others.

You can also set up github actions, to on push to live branch deploy the code to live hosting, by ssh in and run git fetch

name: Deploy via Git Pull
on:
  push:
    branches: main
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - run: mkdir "$HOME/.ssh"
      - run: echo "${{ secrets.KEY }}" > "$HOME/.ssh/key"
      - run: chmod 600 "$HOME/.ssh/key"
      - run: ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no ${{ secrets.USER }}@${{ secrets.HOST }} 'cd /home/homedir && git fetch && git reset --hard origin/main'

One of many good advantages to having your live site as a git repo, is that you get to track any changes or new files, in case something goes wrong or is done to the site.

@domvo
Copy link

domvo commented Jun 8, 2023

@u0421793
Regarding SSH key creation: you only have to do this on the client, not on the server. Basic instructions:

  1. Generate an ssh key on your local machine. Example: ssh-keygen -t ed25519 -C "your_email@example.com". Make sure to NOT enter a passphrase in this step. This adds an extra layer of security that we don't want in our automated scenario.
  2. Then, from your local machine run: ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host. You will probably be asked to provide your ssh password for the user user. This is done only once.
  3. Afterwards verify that your passwordless connection is working by simply running: ssh user@host.

That's it.

Side note: Try to avoid the "whiny" tone and stay professional. This is a volunteer community.

@u0421793
Copy link

u0421793 commented Jun 8, 2023

@u0421793 Regarding SSH key creation: you only have to do this on the client, not on the server. Basic instructions:

  1. Generate an ssh key on your local machine. Example: ssh-keygen -t ed25519 -C "your_email@example.com". Make sure to NOT enter a passphrase in this step.

Ah, don't enter the password, I see – I was entering my password because it was asking

@Nilpo
Copy link
Author

Nilpo commented Jun 9, 2023

You can see from the many comments of successful implementations that this method does, in fact, work.

Yes, the instructions could be slightly clearer concerning what commands are on the client machine and which are on the server. To be honest, I keep them a little cryptic intentionally.

First, this is meant to be a general guideline, not a full instructional. If you know what's happening, these instructions are more than sufficient to make this work. If you can't make it work, it's probably because you shouldn't be trying. There are a lot of security concerns that must be taken into account when implementing this type of solution. Keeping the instructions slightly vague helps to ensure that you actually know what's going on.

When people ask for help, and they seem to have a concept of what they are doing, I always try to make sure that they get it working. But I won't handhold everyone who asks because it's probably not a good idea.

Finally, I've been asked by some to update this with more information, but I will not be doing that. This method is no longer considered best practice. The correct way to do this in 2023 and moving forward is with certificate-based authentication and GitHub Actions. I may put together instructions for this in the future, but I haven't to date because it's far more complicated.

I will continue to respond to requests here and I will also link the new method when I have time to put it together.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment