Menyebarkan proyek menggunakan Git push

Apakah mungkin untuk menggunakan situs web menggunakan git push? Saya punya firasat itu ada hubungannya dengan menggunakan kait git untuk melakukan git reset --harddi sisi server, tapi bagaimana saya bisa menyelesaikan ini?

Saya menemukan script ini di situs ini dan tampaknya bekerja cukup baik.

1. Salin direktori git Anda ke server web Anda

2. Pada salinan lokal Anda, modifikasi file .git / config Anda dan tambahkan server web Anda sebagai remote:

   [remote "production"]
       url = username@webserver:/path/to/htdocs/.git
   

3. Di server, ganti .git / hooks / post-update dengan file ini (dalam jawaban di bawah)

4. Tambahkan akses eksekusi ke file (sekali lagi, di server):

   chmod +x .git/hooks/post-update
   

5. Sekarang, cukup tekan secara lokal ke server web Anda dan itu akan secara otomatis memperbarui copy pekerjaan:

   git push production
   

Menggunakan file pasca pembaruan di bawah ini:

1. Salin direktori git Anda ke server web Anda

2. Pada salinan lokal Anda, modifikasi file .git / config Anda dan tambahkan server web Anda sebagai remote:

   [remote "production"]
       url = username@webserver:/path/to/htdocs/.git
   

3. Di server, ganti .git / hooks / post-update dengan file di bawah ini

4. Tambahkan akses eksekusi ke file (sekali lagi, di server):

   chmod +x .git/hooks/post-update
   

5. Sekarang, cukup tekan secara lokal ke server web Anda dan itu akan secara otomatis memperbarui copy pekerjaan:

   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

Setelah banyak kesalahan awal dan jalan buntu, saya akhirnya dapat menggunakan kode situs web hanya dengan "git push remote " berkat artikel ini .

Script post-update penulis hanya sepanjang satu baris dan solusinya tidak memerlukan konfigurasi .htaccess untuk menyembunyikan repo Git seperti yang dilakukan beberapa orang lain.

Beberapa batu sandungan jika Anda menggunakan ini pada instance Amazon EC2;

1) Jika Anda menggunakan sudo untuk membuat repositori tujuan kosong, Anda harus mengubah pemilik repo ke pengguna ec2 atau push akan gagal. (Coba "chown ec2-user: repo -user ec2 .")

2) Dorongan akan gagal jika Anda tidak melakukan pra-konfigurasi lokasi amazon-private-key .pem Anda, baik di / etc / ssh / ssh_config sebagai parameter IdentityFile atau di ~ / .ssh / config menggunakan "[ Host] - HostName - IdentityFile - User "layout dijelaskan di sini ...

... NAMUN jika Host dikonfigurasi dalam ~ / .ssh / config dan berbeda dari HostName, push Git akan gagal. (Itu mungkin bug Git)

jangan menginstal git di server atau menyalin folder .git di sana. untuk memperbarui server dari klon git, Anda dapat menggunakan perintah berikut:

git ls-files -z | rsync --files-from - --copy-links -av0 . [email protected]:/var/www/project

Anda mungkin harus menghapus file yang dihapus dari proyek.

ini menyalin semua file yang diperiksa. rsync menggunakan ssh yang diinstal pada server.

semakin sedikit perangkat lunak yang Anda instal di server, semakin aman dia dan semakin mudah mengelola konfigurasi dan mendokumentasikannya. juga tidak perlu menyimpan klon git lengkap di server. itu hanya membuatnya lebih kompleks untuk mengamankan semuanya dengan benar.

Intinya semua yang perlu Anda lakukan adalah sebagai berikut:

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

Saya memiliki garis-garis dalam aplikasi saya sebagai executable yang dipanggil deploy.

jadi ketika saya ingin melakukan penyebaran saya ketik ./deploy myserver mybranch.

Cara saya melakukannya adalah saya memiliki repositori telanjang Git di server penempatan tempat saya mendorong perubahan. Kemudian saya masuk ke server penyebaran, mengubah ke direktori server web server yang sebenarnya, dan melakukan git pull. Saya tidak menggunakan pengait untuk mencoba melakukan ini secara otomatis, sepertinya lebih banyak masalah daripada nilainya.

git config --local receive.denyCurrentBranch updateInstead

Ditambahkan di Git 2.3, ini bisa menjadi kemungkinan yang baik: https://github.com/git/git/blob/v2.3.0/Documentation/config.txt#L2155

Anda mengaturnya di repositori server, dan itu juga memperbarui pohon kerja jika itu bersih.

Ada perbaikan lebih lanjut dalam 2.4 dengan push-to-checkoutpengait dan penanganan cabang yang belum lahir .

Penggunaan sampel:

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

Keluaran:

a
b

Ini memang memiliki kekurangan berikut yang disebutkan pada pengumuman GitHub :

• Server Anda akan berisi direktori .git yang berisi seluruh riwayat proyek Anda. Anda mungkin ingin membuat ekstra yakin bahwa itu tidak dapat disajikan kepada pengguna!
• Selama penyebaran, akan mungkin bagi pengguna untuk sesaat menemukan situs dalam keadaan tidak konsisten, dengan beberapa file di versi lama dan yang lain di versi baru, atau bahkan file setengah tertulis. Jika ini merupakan masalah bagi proyek Anda, push-to-deploy mungkin bukan untuk Anda.
• Jika proyek Anda memerlukan langkah "build", maka Anda harus mengaturnya secara eksplisit, mungkin melalui githooks.

Tetapi semua poin tersebut berada di luar lingkup Git dan harus diurus dengan kode eksternal. Jadi dalam hal ini, ini, bersama dengan kait Git, adalah solusi utama.

Pembaruan: Saya sekarang menggunakan solusi Lloyd Moore dengan agen utama ssh -A .... Mendorong ke repo utama dan kemudian menariknya secara paralel dari semua mesin Anda sedikit lebih cepat dan membutuhkan lebih sedikit pengaturan pada mesin-mesin itu.

Tidak melihat solusi ini di sini. tekan saja ssh jika git diinstal di server.

Anda memerlukan entri berikut di .git / config lokal Anda

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

Tapi hei, ada apa dengan itu amazon:? Di ~ / .ssh / config lokal Anda, Anda harus menambahkan entri berikut:

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

sekarang kamu bisa menelepon

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

(BTW: /path/to/project.git berbeda dengan direktori / jalur / ke / proyek kerja aktual)

Untuk Skenario Penempatan

Dalam skenario kami, kami menyimpan kode di github / bitbucket dan ingin menggunakan server langsung. Dalam hal ini, kombinasi berikut berfungsi untuk kami (yang merupakan remix dari jawaban yang sangat dipilih di sini) :

1. Salin .gitdirektori Anda ke server web Anda
2. Di salinan lokal Anda git remote add live ssh://user@host:port/folder
3. Pada jarak jauh: git config receive.denyCurrentBranch ignore

4. Pada jarak jauh: nano .git/hooks/post-receivedan tambahkan konten ini:

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

5. Pada jarak jauh: chmod +x .git/hooks/post-receive

6. Sekarang Anda bisa mendorong ke sana dengan git push live

Catatan

• Solusi ini bekerja dengan versi git yang lebih lama (diuji dengan 1.7 dan 1.9)
• Anda harus memastikan mendorong ke github / bitbucket terlebih dahulu, sehingga Anda akan memiliki repo yang konsisten di live

• Jika .gitfolder Anda di dalam root dokumen pastikan Anda menyembunyikannya dari luar dengan menambahkan .htaccess( sumber ):

  RedirectMatch 404 /\..*$

Kami menggunakan capistrano untuk mengelola penyebaran. Kami membangun capistrano untuk digunakan pada server pementasan, dan kemudian menjalankan rsync dengan semua server kami.

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

Dengan capistrano, kita dapat membuat rollback mudah jika terjadi bug

cap deploy:rollback
cap deploy:start_rsync

Giddyup adalah bahasa-agnostik hanya-tambahkan-air kait git untuk mengotomatiskan penyebaran melalui dorongan git. Hal ini juga memungkinkan Anda untuk memiliki kait start / stop kustom untuk memulai kembali server web, pemanasan cache dll.

https://github.com/mpalmer/giddyup

Lihat contoh .

Sepertinya Anda harus memiliki dua salinan di server Anda. Salinan kosong, tempat Anda dapat mendorong / menarik, yang akan mendorong perubahan saat selesai, dan kemudian Anda akan mengkloning ini ke direktori web Anda dan mengatur cronjob untuk memperbarui git pull dari direktori web Anda setiap hari atau begitu.

Anda bisa mengatur hook git yang ketika mengatakan komit dibuat untuk mengatakan cabang "stable" itu akan menarik perubahan dan menerapkannya ke situs PHP. Kelemahan besar adalah Anda tidak akan memiliki banyak kontrol jika terjadi kesalahan dan itu akan menambah waktu untuk pengujian Anda - tetapi Anda bisa mendapatkan gambaran tentang berapa banyak pekerjaan yang akan terlibat ketika Anda menggabungkan mengatakan cabang trunk Anda ke cabang stabil untuk mengetahui berapa banyak konflik Anda mungkin temui. Penting untuk mengawasi semua file yang spesifik untuk situs (mis. File konfigurasi) kecuali Anda hanya bermaksud menjalankan satu situs saja.

Atau apakah Anda sudah melihat mendorong perubahan ke situs?

Untuk informasi tentang kait git, lihat dokumentasi githooks .

Saya mengambil solusi Kristen .

git archive --prefix=deploy/  master | tar -x -C $TMPDIR | rsync $TMPDIR/deploy/ --copy-links -av [email protected]:/home/user/my_app && rm -rf $TMPDIR/deploy

• Mengarsipkan cabang master ke tar
• Ekstrak arsip tar ke direktori deploy di folder temp sistem.
• perubahan rsync ke server
• hapus deploy dari folder temp.

Saya menggunakan solusi berikut oleh toroid.org , yang memiliki skrip kait yang lebih sederhana.

di server:

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

dan instal hook di server:

$ 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

pada klien Anda:

$ 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

lalu untuk menerbitkan, ketikkan saja

$ git push web

Ada deskripsi lengkap di situs web: http://toroid.org/ams/git-website-howto

Sebagai jawaban pelengkap saya ingin menawarkan alternatif. Saya menggunakan git-ftp dan berfungsi dengan baik.

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

Mudah digunakan, hanya ketik:

git ftp push

dan git akan secara otomatis mengunggah file proyek.

Salam

Diberikan lingkungan di mana Anda memiliki banyak pengembang yang mengakses repositori yang sama, panduan berikut dapat membantu.

Pastikan Anda memiliki grup unix yang dimiliki oleh semua dev dan berikan kepemilikan repositori .git ke grup itu.

1. Dalam .git / config dari repositori server, set sharedrepository = true. (Ini memberitahu git untuk mengizinkan banyak pengguna yang diperlukan untuk melakukan dan menyebarkan.

2. atur umask dari setiap pengguna di file bashrc mereka menjadi sama - 002 adalah awal yang baik

Saya akhirnya membuat alat penyebaran rudimenter saya sendiri yang secara otomatis akan menarik pembaruan baru dari repo - https://github.com/jesalg/SlimJim - Pada dasarnya ia mendengarkan post-accept-hook github dan menggunakan proxy untuk memicu suatu perbarui skrip.

Saya menggunakan dua solusi untuk hook pasca-terima:

SOLUSI TERGANTUNG 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

SOLUSI TERGANTUNG 2

#!/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

Kedua solusi didasarkan pada solusi sebelumnya yang tersedia di utas ini.

Perhatikan, BRANCH_REGEX = '^ $ {GIT_BRANCH1}.filter $ 'untuk nama cabang yang cocok dengan string "master " atau "dev *", dan menyebarkan pohon kerja, jika cabang yang didorong cocok. Ini memungkinkan untuk menyebarkan versi dev dan versi master ke tempat yang berbeda.

SOLUSI DEPLOY 1 hanya menghapus file, yang merupakan bagian dari repo, dan telah dihapus oleh komit. Ini lebih cepat dari Solusi Penerapan 2.

DEPLOY SOLUTION 2 memiliki kelebihan, yaitu akan menghapus semua file baru dari direktori produksi, yang ditambahkan di sisi server, tidak peduli apakah itu ditambahkan ke repo atau tidak. Itu akan selalu bersih dari repo. Ini lebih lambat dari Solusi Penerapan 1.