Déployer un projet en utilisant git push

voix
404

Est - il possible de déployer un site web en utilisant git push? J'ai le pressentiment qu'il a quelque chose à voir avec l' aide de crochets git pour effectuer une git reset --hardsur le côté serveur, mais comment pourrais - je aller accomplir cela?

Créé 10/11/2008 à 22:04
source utilisateur
Dans d'autres langues...                            


19 réponses

voix
9

La façon dont je le fais est que j'ai un dépôt Git nu sur mon serveur de déploiement où je pousse des changements. Puis-je me connecter au serveur de déploiement, changer le répertoire serveur Web réel docs, et faire un git pull. Je n'utilise pas de crochets pour essayer de le faire automatiquement, qui semble être plus d'ennuis que cela vaut la peine.

Créé 10/11/2008 à 22:16
source utilisateur

voix
1

On dirait que vous devriez avoir deux copies sur votre serveur. Une copie nue, que vous pouvez pousser / tirer de, que votre pousserait vos modifications lorsque vous avez terminé, et alors vous cloner cela en vous répertoire web et mettre en place une tâche cron pour mettre à jour git pull à partir de votre répertoire web tous les jours ou alors.

Créé 18/11/2008 à 20:43
source utilisateur

voix
1

Vous pourriez peut mettre en place un crochet git que lorsque dire Commit est fait dire la branche « stable » , elle va tirer les changements et les appliquer au site PHP. Le grand inconvénient est que vous ne serez pas avoir beaucoup de contrôle , si quelque chose va mal et il va ajouter du temps à vos tests - mais vous pouvez avoir une idée de la quantité de travail sera impliqué lors de la fusion que votre branche de tronc dans la branche stable de savoir combien de conflits vous pouvez rencontrer. Il sera important de garder un œil sur tous les fichiers qui sont spécifiques du site (par exemple. Les fichiers de configuration) , sauf si vous avez l' intention uniquement pour exécuter uniquement le seul site.

Sinon avez-vous regardé en poussant le changement sur le site à la place?

Pour plus d' informations sur des crochets git voir la githooks documentation.

Créé 18/11/2008 à 21:28
source utilisateur

voix
283

J'ai trouvé ce script sur ce site et il semble fonctionner assez bien.

  1. Copier sur votre répertoire .git à votre serveur web
  2. Sur votre copie locale, modifiez votre .git / fichier de configuration et ajoutez votre serveur web comme une télécommande:

    [remote "production"]
        url = username@webserver:/path/to/htdocs/.git
    
  3. Sur le serveur, remplacez .git / hooks / post-mise à jour avec ce fichier (dans la réponse ci - dessous)

  4. Ajouter exécuter l'accès au fichier (encore une fois, sur le serveur):

    chmod +x .git/hooks/post-update
    
  5. Maintenant, il suffit de pousser localement sur votre serveur Web et il devrait automatiquement mettre à jour la copie de travail:

    git push production
    
Créé 29/11/2008 à 08:37
source utilisateur

voix
12

Essentiellement tout ce que vous devez faire sont les suivantes:

server = $1
branch = $2
git push $server $branch
ssh <username>@$server "cd /path/to/www; git pull"

J'ai ces lignes dans mon application comme un fichier exécutable appelé deploy.

quand je veux faire un Déployez type I ./deploy myserver mybranch.

Créé 10/05/2010 à 22:33
source utilisateur

voix
76

Utilisation de la post-mise à jour le fichier ci - dessous:

  1. Copier sur votre répertoire .git à votre serveur web
  2. Sur votre copie locale, modifiez votre .git / fichier de configuration et ajoutez votre serveur web comme une télécommande:

    [remote "production"]
        url = username@webserver:/path/to/htdocs/.git
    
  3. Sur le serveur, remplacez .git / hooks / post-mise à jour avec le fichier ci-dessous

  4. Ajouter exécuter l'accès au fichier (encore une fois, sur le serveur):

    chmod +x .git/hooks/post-update
    
  5. Maintenant, il suffit de pousser localement sur votre serveur Web et il devrait automatiquement mettre à jour la copie de travail:

    git push production
    
#!/bin/sh
#
# This hook does two things:
#
#  1. update the "info" files that allow the list of references to be
#     queries over dumb transports such as http
#
#  2. if this repository looks like it is a non-bare repository, and
#     the checked-out branch is pushed to, then update the working copy.
#     This makes "push" function somewhat similarly to darcs and bzr.
#
# To enable this hook, make this file executable by "chmod +x post-update". 
git-update-server-info 
is_bare=$(git-config --get --bool core.bare) 
if [ -z "$is_bare" ]
then
      # for compatibility's sake, guess
      git_dir_full=$(cd $GIT_DIR; pwd)
      case $git_dir_full in */.git) is_bare=false;; *) is_bare=true;; esac
fi 
update_wc() {
      ref=$1
      echo "Push to checked out branch $ref" >&2
      if [ ! -f $GIT_DIR/logs/HEAD ]
      then
             echo "E:push to non-bare repository requires a HEAD reflog" >&2
             exit 1
      fi
      if (cd $GIT_WORK_TREE; git-diff-files -q --exit-code >/dev/null)
      then
             wc_dirty=0
      else
             echo "W:unstaged changes found in working copy" >&2
             wc_dirty=1
             desc="working copy"
      fi
      if git diff-index --cached HEAD@{1} >/dev/null
      then
             index_dirty=0
      else
             echo "W:uncommitted, staged changes found" >&2
             index_dirty=1
             if [ -n "$desc" ]
             then
                   desc="$desc and index"
             else
                   desc="index"
             fi
      fi
      if [ "$wc_dirty" -ne 0 -o "$index_dirty" -ne 0 ]
      then
             new=$(git rev-parse HEAD)
             echo "W:stashing dirty $desc - see git-stash(1)" >&2
             ( trap 'echo trapped $$; git symbolic-ref HEAD "'"$ref"'"' 2 3 13 15 ERR EXIT
             git-update-ref --no-deref HEAD HEAD@{1}
             cd $GIT_WORK_TREE
             git stash save "dirty $desc before update to $new";
             git-symbolic-ref HEAD "$ref"
             )
      fi 
      # eye candy - show the WC updates :)
      echo "Updating working copy" >&2
      (cd $GIT_WORK_TREE
      git-diff-index -R --name-status HEAD >&2
      git-reset --hard HEAD)
} 
if [ "$is_bare" = "false" ]
then
      active_branch=`git-symbolic-ref HEAD`
      export GIT_DIR=$(cd $GIT_DIR; pwd)
      GIT_WORK_TREE=${GIT_WORK_TREE-..}
      for ref
      do
             if [ "$ref" = "$active_branch" ]
             then
                   update_wc $ref
             fi
      done
fi
Créé 02/08/2010 à 11:53
source utilisateur

voix
59

Après plusieurs faux départs et des impasses, je suis enfin en mesure de déployer le code de site Web avec juste « git pousser à distance » grâce à cet article .

Le script de post-mise à jour de l'auteur est qu'une seule ligne et sa solution ne nécessite pas de configuration .htaccess pour cacher la prise en pension Git comme d'autres le font.

Quelques pierres d'achoppement si vous déployez cela sur une instance Amazon EC2;

1) Si vous utilisez la commande sudo pour créer le référentiel de destination nue, vous devez changer le propriétaire du repo à EC2-utilisateur ou la poussée échouera. (Essayez "EC2 utilisateur chown: EC2 utilisateur repo ".)

2) La poussée échouera si vous ne préconfigurer l'emplacement de votre amazon-clé privée .pem, que ce soit dans / etc / ssh / ssh_config comme paramètre IdentityFile ou dans ~ / .ssh / config en utilisant le « [ hôte] - Nom d' hôte - IdentityFile - utilisateur » mise en page décrit ici ...

... si l'hôte est configuré dans ~ / .ssh / config et différent de l'hostname la poussée Git échouera. (C'est probablement un bug Git)

Créé 03/03/2011 à 07:31
source utilisateur

voix
21

DonT installer git sur un serveur ou copiez le dossier .git là. mettre à jour un serveur à partir d'un clone git, vous pouvez utiliser la commande suivante:

git ls-files -z | rsync --files-from - --copy-links -av0 . user@server.com:/var/www/project

vous pourriez avoir à supprimer des fichiers qui a obtenu retirés du projet.

cette copie tous les fichiers archivés. rsync utilise ssh qui est installé sur un serveur de toute façon.

le logiciel moins que vous avez installé sur un serveur plus sécurisé, il est et plus il est facile de gérer sa configuration et le documenter. il n'y a pas non plus besoin de garder un clone git complet sur le serveur. il ne fait que plus complexe pour sécuriser tout correctement.

Créé 24/08/2011 à 07:54
source utilisateur

voix
0

Dans un environnement où vous avez plusieurs développeurs qui accèdent au même référentiel les lignes directrices suivantes peuvent aider.

Assurez-vous que vous avez un groupe unix que tous les devs appartiennent et donnent la propriété du dépôt .git à ce groupe.

  1. Dans le .git / config du jeu référentiel du serveur sharedrepository = true. (Cela dit git pour permettre à plusieurs utilisateurs qui est nécessaire pour commits et le déploiement.

  2. définir le umask de chaque utilisateur dans leurs fichiers Bashrc être le même - 002 est un bon début

Créé 16/09/2011 à 12:04
source utilisateur

voix
2

Giddyup sont la langue agnostique juste-add-eau crochets git pour automatiser le déploiement via git push. Il vous permet également d'avoir démarrer / arrêter sur mesure pour le redémarrage des crochets serveur web, réchauffant cache , etc.

https://github.com/mpalmer/giddyup

Consultez des exemples .

Créé 11/10/2011 à 15:15
source utilisateur

voix
5

Mise à jour: J'utilise maintenant Lloyd Moore solution avec l'agent clé ssh -A .... Pousser à un repo principal, puis en tirant à partir en parallèle de toutes vos machines est un peu plus rapide et nécessite moins d' installation sur ces machines.


Ne voyant pas cette solution ici. il suffit de pousser via ssh si git est installé sur le serveur.

Vous aurez besoin de l'entrée suivante dans votre .git local / config

[remote "amazon"]
    url = amazon:/path/to/project.git
    fetch = +refs/heads/*:refs/remotes/amazon/*

Mais bon, ce qui est avec qui amazon:? Dans votre région ~ / .ssh / config vous devez ajouter l'entrée suivante:

Host amazon
    Hostname <YOUR_IP>
    User <USER>
    IdentityFile ~/.ssh/amazon-private-key

Maintenant, vous pouvez appeler

git push amazon master
ssh <USER>@<YOUR_IP> 'cd /path/to/project && git pull'

(BTW: /path/to/project.git est différent du répertoire de travail réel / chemin / vers / projet)

Créé 26/11/2011 à 17:21
source utilisateur

voix
0

J'ai fini par créer mon propre outil de déploiement rudimentaire qui rassemblerait automatiquement les mises à jour de nouvelles de la mise en pension - https://github.com/jesalg/SlimJim - Fondamentalement , il écoute le github post-réception-crochet et utilise un proxy pour déclencher une script de mise à jour.

Créé 07/05/2012 à 21:50
source utilisateur

voix
4

Nous utilisons Capistrano pour la gestion Deploy. Nous construisons Capistrano à déployer sur un serveur intermédiaire, puis de rsync avec tous serveur nôtre.

cap deploy
cap deploy:start_rsync (when the staging is ok)

Avec Capistrano, nous pouvons en rollback facile en cas de bug

cap deploy:rollback
cap deploy:start_rsync
Créé 29/11/2012 à 19:16
source utilisateur

voix
1

Mon point de vue sur les chrétiens solution.

git archive --prefix=deploy/  master | tar -x -C $TMPDIR | rsync $TMPDIR/deploy/ --copy-links -av username@server.com:/home/user/my_app && rm -rf $TMPDIR/deploy
  • Archives de la branche principale en goudron
  • Extrait archive tar en déploiement dir dans le dossier temporaire du système.
  • changements dans rsync serveur
  • supprimer le déploiement dir du dossier temp.
Créé 06/09/2013 à 23:01
source utilisateur

voix
1

J'utilise la solution suivante par toroid.org , qui a un script hook plus simple.

sur le serveur:

$ mkdir website.git && cd website.git
$ git init --bare
Initialized empty Git repository in /home/ams/website.git/

et installer le crochet sur le serveur:

$ mkdir /var/www/www.example.org
$ cat > hooks/post-receive
#!/bin/sh
GIT_WORK_TREE=/var/www/www.example.org git checkout -f
GIT_WORK_TREE=/var/www/www git clean -f -d # clean directory from removed files

$ chmod +x hooks/post-receive

sur votre client:

$ mkdir website && cd website
$ git init
Initialized empty Git repository in /home/ams/website/.git/
$ echo 'Hello, world!' > index.html
$ git add index.html
$ git commit -q -m "The humble beginnings of my web site."

$ git remote add web ssh://server.example.org/home/ams/website.git
$ git push web +master:refs/heads/master

puis de publier, il suffit de taper

$ git push web

Il y a une description complète sur le site: http://toroid.org/ams/git-website-howto

Créé 21/03/2014 à 12:43
source utilisateur

voix
7

receive.denyCurrentBranch updateInstead ajouté en 2.3 Git est une possibilité.

Réglez-le sur le référentiel du serveur, et il met également à jour l'arbre de travail si elle est propre.

Il y a eu d' autres améliorations à 2.4 avec le push-to-checkoutcrochet et la manipulation des branches à naître .

Exemple d'utilisation:

git init server
cd server
touch a
git add .
git commit -m 0
git config --local receive.denyCurrentBranch updateInstead

cd ..
git clone server local
cd local
touch b
git add .
git commit -m 1
git push origin master:master

cd ../server
ls

Sortie:

a
b

Cela ne les lacunes suivantes mentionnées sur l'annonce GitHub :

  • Votre serveur contiendra un répertoire .git contenant toute l'histoire de votre projet. Vous voulez sans doute faire de plus sûr qu'il ne peut pas être servi aux utilisateurs!
  • Au cours de Déploie, il sera possible pour les utilisateurs momentanément de rencontrer le site dans un état incohérent, avec certains fichiers à l'ancienne version et d'autres à la nouvelle version, ou même des fichiers demi-écrits. Si cela est un problème pour votre projet, push-to-Deploy est probablement pas pour vous.
  • Si votre projet a besoin d'une étape « construire », alors vous devrez établir cela explicitement, peut-être via githooks.

Mais tous ces points sont hors de la portée de Git et doit être pris en charge par le code externe. En ce sens, ce qui, avec des crochets Git, sont la solution ultime.

Créé 07/02/2015 à 10:51
source utilisateur

voix
1

En réponse complémentaire, je voudrais proposer une alternative. J'utilise git-ftp et il fonctionne très bien.

https://github.com/git-ftp/git-ftp

Facile à utiliser, seul type:

git ftp push

et git téléchargera automatiquement les fichiers de projet.

Cordialement

Créé 04/05/2015 à 11:55
source utilisateur

voix
4

Pour le scénario de déploiement

Dans notre scénario , nous nous stockons le code sur GitHub / bitbucket et que vous souhaitez déployer pour vivre des serveurs. Dans ce cas , la combinaison suivante fonctionne pour nous (qui est un remix des réponses très upvoted ici) :

  1. Copier sur votre .gitrépertoire sur votre serveur web
  2. Sur votre copie locale git remote add live ssh://user@host:port/folder
  3. Sur distance: git config receive.denyCurrentBranch ignore
  4. Sur distance: nano .git/hooks/post-receiveet ajouter ce contenu:

    #!/bin/sh GIT_WORK_TREE=/var/www/vhosts/example.org git checkout -f

  5. Sur distance: chmod +x .git/hooks/post-receive

  6. Maintenant, vous pouvez pousser là-bas avec git push live

Remarques

  • Cette solution fonctionne avec les versions git âgées (testé avec 1,7 et 1,9)
  • Vous devez vous assurer de pousser à github / bitbucket premier, vous aurez une prise en pension cohérente sur le Live
  • Si votre .gitdossier est à la racine des documents assurez-vous cacher de l'extérieur en ajoutant à .htaccess( la source ):

    RedirectMatch 404 /\..*$

Créé 17/10/2015 à 09:45
source utilisateur

voix
0

J'utilise deux solutions pour crochet post-recevoir:

Déployer une solution 1

#!/bin/bash 
#  /git-repo/hooks/post-receive - file content on server (chmod as 755 to be executed)
# DEPLOY SOLUTION 1 

    export GIT_DIR=/git/repo-bare.git
    export GIT_BRANCH1=master
    export GIT_TARGET1=/var/www/html
    export GIT_BRANCH2=dev
    export GIT_TARGET2=/var/www/dev
    echo "GIT DIR:  $GIT_DIR/"
    echo "GIT TARGET1:  $GIT_TARGET1/"
    echo "GIT BRANCH1:  $GIT_BRANCH1/"
    echo "GIT TARGET2:  $GIT_TARGET2/"
    echo "GIT BRANCH2:  $GIT_BRANCH2/"
    echo ""

    cd $GIT_DIR/

while read oldrev newrev refname
do
    branch=$(git rev-parse --abbrev-ref $refname)
    BRANCH_REGEX='^${GIT_BRANCH1}.*$'
    if [[ $branch =~ $BRANCH_REGEX ]] ; then
        export GIT_WORK_TREE=$GIT_TARGET1/.
        echo "Checking out branch: $branch";
        echo "Checking out to workdir: $GIT_WORK_TREE"; 

        git checkout -f $branch
    fi

    BRANCH_REGEX='^${GIT_BRANCH2}.*$'
    if [[ $branch =~ $BRANCH_REGEX ]] ; then
        export GIT_WORK_TREE=$GIT_TARGET2/.
        echo "Checking out branch: $branch";
        echo "Checking out to workdir: $GIT_WORK_TREE"; 

        git checkout -f $branch
    fi
done

SOLUTION 2 DÉPLOIEMENT

#!/bin/bash 
#  /git-repo/hooks/post-receive - file content on server (chmod as 755 to be executed)
# DEPLOY SOLUTION 2

    export GIT_DIR=/git/repo-bare.git
    export GIT_BRANCH1=master
    export GIT_TARGET1=/var/www/html
    export GIT_BRANCH2=dev
    export GIT_TARGET2=/var/www/dev
    export GIT_TEMP_DIR1=/tmp/deploy1
    export GIT_TEMP_DIR2=/tmp/deploy2
    echo "GIT DIR:  $GIT_DIR/"
    echo "GIT TARGET1:  $GIT_TARGET1/"
    echo "GIT BRANCH1:  $GIT_BRANCH1/"
    echo "GIT TARGET2:  $GIT_TARGET2/"
    echo "GIT BRANCH2:  $GIT_BRANCH2/"
    echo "GIT TEMP DIR1:  $GIT_TEMP_DIR1/"
    echo "GIT TEMP DIR2:  $GIT_TEMP_DIR2/"
    echo ""

    cd $GIT_DIR/

while read oldrev newrev refname
do
    branch=$(git rev-parse --abbrev-ref $refname)
    BRANCH_REGEX='^${GIT_BRANCH1}.*$'
    if [[ $branch =~ $BRANCH_REGEX ]] ; then
        export GIT_WORK_TREE=$GIT_TARGET1/.
        echo "Checking out branch: $branch";
        echo "Checking out to workdir: $GIT_WORK_TREE"; 

        # DEPLOY SOLUTION 2: 
        cd $GIT_DIR/; mkdir -p $GIT_TEMP_DIR1; 
        export GIT_WORK_TREE=$GIT_TEMP_DIR1/.
        git checkout -f $branch
        export GIT_WORK_TREE=$GIT_TARGET1/.
        rsync $GIT_TEMP_DIR1/. -v -q --delete --delete-after -av $GIT_TARGET1/.
        rm -rf $GIT_TEMP_DIR1
    fi

    BRANCH_REGEX='^${GIT_BRANCH2}.*$'
    if [[ $branch =~ $BRANCH_REGEX ]] ; then
        export GIT_WORK_TREE=$GIT_TARGET2/.
        echo "Checking out branch: $branch";
        echo "Checking out to workdir: $GIT_WORK_TREE"; 

        # DEPLOY SOLUTION 2: 
        cd $GIT_DIR/; mkdir -p $GIT_TEMP_DIR2; 
        export GIT_WORK_TREE=$GIT_TEMP_DIR2/.
        git checkout -f $branch
        export GIT_WORK_TREE=$GIT_TARGET2/.
        rsync $GIT_TEMP_DIR2/. -v -q --delete --delete-after -av $GIT_TARGET2/.
        rm -rf $GIT_TEMP_DIR2
    fi
done

Les deux solutions sont basées sur des solutions antérieures disponibles dans ce fil.

Remarque, la BRANCH_REGEX = '^ $ {} GIT_BRANCH1. Filtres « $ pour les noms de branche correspondant à « maître » ou « dev * » string, et déploie l'arbre de travail, si les matches de branche poussé. Cela permet de déployer une version dev et la version maître à différents endroits.

SOLUTION 1 supprime DEPLOY uniquement les fichiers qui font partie de la pension, et a été enlevé par un commit. Il est plus rapide que la solution de déploiement 2.

SOLUTION 2 a DEPLOY l'avantage, qu'il supprime tous les nouveaux fichiers à partir du répertoire de production, qui a été ajouté sur le côté serveur, peu importe si elle a été ajoutée à la mise en pension ou non. Il sera toujours propre dupe de la pension. Il est plus lent que le déploiement Solution 1.

Créé 15/02/2016 à 10:42
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more