GitHub, and therefore the dirty dog version system it’s supported, ar fantastic tools for managing and collaborating on comes – code-based or otherwise.
In this article, we’ll examine choices for creating dirty dog and GitHub comes match higher into developer workflows, permitting a swish and inactive readying method.
I’ll break these choices into the various sorts of toolsets out there – which permit for choices from mechanically running tests and code checks to deploying your code to a server.
Why Do This?
With these machine-driven processes up and running, you and your team will focus strictly on committal to writing, approving and merging code, instead of disbursal hours on deployments and repetitive tasks each time a replacement build or amendment is prepared.
Disadvantages of Automation
The main downside with mechanically deploying changes is that changes ar mechanically deployed. you've got to trust your team and therefore the code they write. this can be why automatic readying is usually paired with machine-driven testing, and therefore the tools conferred below mirror this.
additional from this author
Blink(1), a Programmable Indicator for All Developer wants
The Next Full Stack Language? Server-side Swift with excellent
Of course, it additionally means any tiny problems ar equally as fast to mend. Automation ought to be paired with communication. If pushing to a repository’s master branch will trigger live builds, it has to be clear once this happens and World Health Organization will build it happen.
The initial setup of Associate in Nursing automation method will take a while to induce right. It’s necessary to weigh up whether or not or not your team or advancement extremely wants it. Add up the number of your time you pay on testing and deploying new builds – and if it’s over many minutes anytime, then it’s worthwhile.
Git Hooks
Git encompasses a suite of in-built hooks that may be used for automation, and these ar typically our initial port of require process tasks when specific dirty dog actions. These ar divided into server- and client-side hooks.
Server-side hooks ar for events like taking note of network operations – for instance, once a repository receives a push. Client-side hooks ar triggered on actions that occur on a developer’s machine, like commits and merges.
There’s a full list of hooks in Git’s documentation. I’ll examine some here to induce you started. Hopefully you’ll begin to envision however they will be helpful in your own comes and current (manual) workflows. The hooks ar files {that will|which will|that may} contain commands in any language the host system can run, permitting plenty of power and suppleness.
In this article, we’ll examine choices for creating dirty dog and GitHub comes match higher into developer workflows, permitting a swish and inactive readying method.
I’ll break these choices into the various sorts of toolsets out there – which permit for choices from mechanically running tests and code checks to deploying your code to a server.
With these machine-driven processes up and running, you and your team will focus strictly on committal to writing, approving and merging code, instead of disbursal hours on deployments and repetitive tasks each time a replacement build or amendment is prepared.
Disadvantages of Automation
The main downside with mechanically deploying changes is that changes ar mechanically deployed. you've got to trust your team and therefore the code they write. this can be why automatic readying is usually paired with machine-driven testing, and therefore the tools conferred below mirror this.
additional from this author
Blink(1), a Programmable Indicator for All Developer wants
The Next Full Stack Language? Server-side Swift with excellent
Of course, it additionally means any tiny problems ar equally as fast to mend. Automation ought to be paired with communication. If pushing to a repository’s master branch will trigger live builds, it has to be clear once this happens and World Health Organization will build it happen.
The initial setup of Associate in Nursing automation method will take a while to induce right. It’s necessary to weigh up whether or not or not your team or advancement extremely wants it. Add up the number of your time you pay on testing and deploying new builds – and if it’s over many minutes anytime, then it’s worthwhile.
Git Hooks
Git encompasses a suite of in-built hooks that may be used for automation, and these ar typically our initial port of require process tasks when specific dirty dog actions. These ar divided into server- and client-side hooks.
Server-side hooks ar for events like taking note of network operations – for instance, once a repository receives a push. Client-side hooks ar triggered on actions that occur on a developer’s machine, like commits and merges.
There’s a full list of hooks in Git’s documentation. I’ll examine some here to induce you started. Hopefully you’ll begin to envision however they will be helpful in your own comes and current (manual) workflows. The hooks ar files {that will|which will|that may} contain commands in any language the host system can run, permitting plenty of power and suppleness.
pre-commit
This client-side hook runs before any other hook, and before any changes are committed. It’s a perfect place to run tests or other checks on your code.
Let’s add some basic JavaScript to our small project (and yes, there is an intentional mistake here):
document.onload = function() {
alert("Hello World")
};
We’ll use JSHint to check the JavaScript for errors. (You can find installation instructions here.)
Rename
hooks/pre-commit.sample to hooks/pre-commit, and change the contents of the file to this:#!/bin/sh
jshint index.js
Try to commit the changes:
git commit -m "adding Javascript file"
You’ll see the following error message:
index.js: line 5, col 25, Missing semicolon.
1 error
Add the missing semicolon and try again. The commit will now progress without any problems.
post-receive
This server-side hook triggers when a push to a remote Git repository completes. In this example, we checkout the latest version of a simple website into our webserver directory, effectively a (basic) deployment.
I have an existing website that consists of an
index.html page – along with some other pages that we’ll use in later examples. You can create your own or use the repository set up here.
Clone the repository, specifying the
--bare flag to create a repository that only consists of version control information and not our code base:git clone --bare https://github.com/sitepoint-editors/GitHub-Auto-Deploy.git GitHub-Auto-Deploy.git
Now we’ll create our hook:
cd GitHub-Auto-Deploy.git/hooks
vi post-receive
Add these lines to the file:
#!/bin/sh
git --work-tree=/var/www/html --git-dir=/var/repo/GitHub-Auto-Deploy.git checkout -f
Note: these locations are relevant to an Ubuntu installation, so remember to change paths to suit your setup.
This command will checkout the current repository into the defined working directory, but without any version control data.
We need to make the hook executable:
chmod +x post-receive
On your local machine, clone the repository as normal, using your tool of choice, and add a new remote for the live server (remember to change the server details to your webserver and user details):
git remote add prod ssh://user@domain.com/var/repo/GitHub-Auto-Deploy.git
To deploy to our production server instead of the repository, enter:
git push prod master
If you look inside the
var/www/html folder, you’ll find the index.html file automatically copied into your web folder.
If you’re using your own Git repository, you can have it located on the same server as your application, and deployments are now automated. If you’re using GitHub or another external Git service, then this hook has not completely automated your workflow, but rather has reduced it to one step. This can then be simplified further.
One option is using rsync or scp commands in the
post-receive hook on GitHub. Another option – especially if your application needs a build process before going live (GitHub limits possible commands) – is to use the post-receive hook to trigger scripts on your application server that checks-out your code base from GitHub (with the -f option) and runs any other necessary commands. This is starting to get complicated, which leads nicely to our next set of tools.Autodeployment Directly from GitHub
GitHub has its own documentation for automating deployments to integration platforms, some of which are hosting providers.
To be honest, most of the documentation I checked out was incorrect, inaccurate or unhelpful, so I did some searching to link to official documentation on some popular hosting providers, and for any others I suggest you use the
post-receive or continuous integration methods:Continuous Integration (CI) Services
There are a myriad services available that can watch your GitHub repos for changes and not only then deploy them for you, but also perform other functions such as running tests and build processes for you.
Moving to a new and more complex example, we could use CI to automate the build process of a project. Firstly, pulling the
Master branch of a repository, triggering a bash script to run the build and deploy process, and then tweeting about the updates. The CI and web services could be on the same server or on different servers depending on your preference.
Let’s take a quick look at some of the most popular.
Jenkins
You’ll need to set up your own Jenkins server, which means you get complete control, but it requires maintenance. Fortunately, it supports many platforms, including Docker if you just want to experiment first.
Jenkins achieves most of its functionality with plugins, and thanks to its age, open-source nature and popularity, it has a lot of plugins. For example, there are plugins for Git, GitHub and Twitter.
Jenkins requires a lot of configuration, and sometimes piecing together the instructions you need to construct your desired workflow can require a lot of research.
Travis
Again, the instructions for integrating Travis with GitHub are out of date in GitHub’s documentation. It’s even more simple now: read the Travis docs to find out more.
Travis doesn’t require any hosting or server setup, so if you’re keen to try CI without investing too much setup time, it’s a good starting point. However, extending it beyond its (comprehensive) default integrations will involve some extra config work. For example, Tweeting requires access to webhooks.
Travis has a habit of being slow to notice updates in your repos – especially in its own configuration file. These issues can then be hard to solve, as you have no access to the Travis server itself.
Other Commercial Services
Continuous integration is increasingly popular, so there’s been a plethora of new services and applications – many released by the creators of tools you may already be using, and which will fit snugly into existing toolchains and workflows. Here are some examples:
- https://buddy.works/
- https://www.atlassian.com/software/bamboo/
- https://www.jetbrains.com/teamcity/
- https://codeship.com/
- https://circleci.com/
- https://saucelabs.com/
- https://about.gitlab.com/gitlab-ci/
- http://deploybot.com/
Wrap Up
Hopefully this brief introduction has clarified a few things for you regarding how this kind of deployment works. We’ve certainly come a long way from the days of FTPing your files to your server!
Deploying from GitHub to a Server
![Deploying from GitHub to a Server]()
Reviewed by JohnBlogger
on
5:11 PM
Rating:
No comments: