deploy-golang-docker-nginx-loadbalancing

DEPLOY GOLANG WITH DOCKER AND LOADBALANCING BY DOCKER NGINX

Step 1: docker-setup.sh

#!/bin/bash  
read -p "Enter work folder (ex: /srv): " SRV
[ $SRV ] && [ -s $SRV ] && echo "Work folder: "$SRV || exit
read -p "Enter PROJECT: " PROJECT
[ -s $PROJECT ] && exit || echo "PROJECT "$PROJECT
read -p "Enter IPSERVER: " IPSERVER
[ -s $IPSERVER ] && exit || echo "IPSERVER "$IPSERVER
read -p "Enter IPSERVER: " IPSERVER
[ -s $IPSERVER ] && exit || echo "IPSERVER "$IPSERVER
echo "--------------------BEGIN-----------------------"
 
echo "BEGIN SETUP PROJECT "$PROJECT
TMP=$SRV/tmp/ && echo "+ TMP "$TMP
WWW=$SRV/www/ && echo "+ WWW "$WWW
GIT=$SRV/git/ && echo "+ GIT "$GIT
ENV=$SRV/env/ && echo "+ ENV "$ENV
echo "------------------------------------------------"
 
[ ! -d $TMP ] && sudo mkdir -p $TMP && echo $TMP" created" && sudo chgrp -R users $TMP && echo $TMP" chgrp users" && sudo chmod g+w $TMP && echo $TMP" chmod g+w" || echo $TMP" find"
[ ! -d $WWW ] && sudo mkdir -p $WWW && echo $WWW" created" && sudo chgrp -R users $WWW && echo $WWW" chgrp users" && sudo chmod g+w $WWW && echo $WWW" chmod g+w" || echo $WWW" find"
echo "------------------------------------------------"
 
[ ! -d $GIT$PROJECT.git ] && sudo mkdir -p $GIT$PROJECT.git && echo $GIT$PROJECT.git" created" || echo $GIT$PROJECT.git" find"
cd $GIT$PROJECT.git/ && echo "cd $GIT$PROJECT.git/"
echo "------------------------------------------------"
 
sudo git init --bare && echo "git init --bare"
echo "------------------------------------------------"
 
sudo chgrp -R users . && echo "chgrp -R users ."
sudo chmod -R g+rwX . && echo "chmod -R g+rwX ."
sudo find . -type d -exec chmod g+s '{}' + && echo "find . -type d -exec chmod g+s '{}' +"
echo "------------------------------------------------"
 
sudo git config core.sharedRepository group && echo "git config core.sharedRepository group"
echo "------------------------------------------------"
 
cd $GIT$PROJECT.git/hooks/ && echo "cd $GIT$PROJECT.git/hooks/"
echo "------------------------------------------------"
 
sudo rm $GIT$PROJECT.git/hooks/post-receive && echo "rm $GIT$PROJECT.git/hooks/post-receive"
sudo echo '#!/bin/bash
 
# The production directory 
WWW='$WWW$PROJECT'
 
# A temporary directory for deployment 
TMP='$TMP$PROJECT'
 
# The Git repo 
GIT='$GIT$PROJECT.git'
 
# The Env  repo 
ENV='$ENV$PROJECT'
 
# Deploy the content to the temporary directory 
mkdir -p $TMP
git --work-tree=$TMP --git-dir=$GIT checkout -f
 
# Copy the env variable to the temporary directory 
cp -a $ENV/. $TMP
 
# Do stuffs, like npm install 
cd $TMP || exit
 
# Replace the content of the production directory 
# with the temporary directory 
cd / || exit
rm -rf $WWW
mv $TMP $WWW
 
# Do stuff like starting docker 
cd $WWW || exit
# docker-compose up -d --build 
chmod 777 run
$PWD/run' >> $GIT$PROJECT.git/hooks/post-receive && echo $GIT$PROJECT.git/hooks/post-receive" created"
 
sudo touch $GIT$PROJECT.git/hooks/post-receive && echo "touch $GIT$PROJECT.git/hooks/post-receive"
sudo chmod +x $GIT$PROJECT.git/hooks/post-receive && echo "chmod +x $GIT$PROJECT.git/hooks/post-receive"
 
echo '---------------------------------------------'
echo ''
echo 'git remote add deploy ssh://root@'$IPSERVER$GIT$PROJECT'.git/'
echo 'git add .'
echo 'git commit -m "first commit"'
echo 'git push deploy master'

Step 2:

sudo -i
 
snap install docker
apt install docker-composer
 
sh /path/to/docker-setup.sh

Step 3: local-setup.sh

#!/bin/bash 
read -p "Enter work folder server (ex: /srv): " SRV
[ $SRV ] && [ -s $SRV ] && echo "Work folder: "$SRV || exit
read -p "Enter PROJECT: " PROJECT
[ -s $PROJECT ] && exit || echo "PROJECT "$PROJECT
read -p "Enter ipv4 IPSERVER: " IPSERVER
[ -s $IPSERVER ] && exit || echo "IPSERVER "$IPSERVER
read -p "Enter GOLANG RUN PORT (ex: 8080): " PORT
[ -s $PORT ] && exit || echo "GOLANG RUN PORT "$PORT
echo "--------------------BEGIN-----------------------"
 
go mod init $PROJECT
 
rm run && echo "rm run"
echo '#!/bin/bash
sudo docker-compose down
sudo docker image rm '$PROJECT'
sudo docker-compose up --build -d' >> run && echo run" created"
 
 
rm Dockerfile && echo "rm Dockerfile"
echo 'FROM golang:alpine
# app directory
WORKDIR /usr/goapp/'$PROJECT'
COPY . .
RUN ["go", "build", "."]
EXPOSE '$PORT'
CMD $PWD/'$PROJECT'
 
# sudo docker build -t go-app .
# sudo docker run -p 5001:'$PORT' go-app &
# sudo docker run -p 5002:'$PORT' go-app &
# sudo docker run -p 5003:'$PORT' go-app &' >> Dockerfile && echo Dockerfile" created"
 
rm docker-compose.yml && echo "rm docker-compose.yml"
echo 'version: "3"
services:
    '$PROJECT'1:
        image: '$PROJECT'
        ports:
            - 5001:'$PORT'
        container_name: '$PROJECT'1
    '$PROJECT'2:
        image: '$PROJECT'
        ports:
            - 5002:'$PORT'
        container_name: '$PROJECT'2
    '$PROJECT'3:
        build: .
        image: '$PROJECT'
        ports:
            - 5003:'$PORT'
        container_name: '$PROJECT'3
    nginxloadbalancing:
        image: nginx:alpine
        volumes:
            - ./conf.d:/etc/nginx/conf.d
        ports:
            - 5554:8000
            - '$PORT':'$PORT'
        container_name: nginxloadbalancing' >> docker-compose.yml && echo docker-compose.yml" created"
 
mkdir conf.d
 
rm conf.d/go-loadbalancing.conf && echo "rm conf.d/go-loadbalancing.conf"
echo 'upstream loadbalance {
    least_conn;
    server google.com;
    server bing.com;
    server websearch.com;
    server wikipedia.org;
}
 
server {
    listen 8000;
    listen [::]:8000;
    server_name _;
    location / {
        proxy_pass http://loadbalance;
    }
}
 
upstream goapi {
    least_conn;
    server '$IPSERVER':5001;
    server '$IPSERVER':5002;
    server '$IPSERVER':5003;
}
 
server {
    listen '$PORT';
    listen [::]:'$PORT';
    server_name _;
    location / {
        proxy_pass http://goapi;
    }
}' >> conf.d/go-loadbalancing.conf && echo conf.d/go-loadbalancing.conf" created"

Step 4:

# LOCAL DEPLOY  
read -p "Enter work folder server (ex: /srv): " SRV && echo "SRV "$SRV
read -p "Enter PROJECT: " PROJECT && echo "PROJECT "$PROJECT
read -p "Enter ipv4 IPSERVER: " IPSERVER && echo "IPSERVER ipv4 "$IPSERVER
read -p "Enter GOLANG RUN PORT (ex: 8080): " PORT && echo "GOLANG RUN PORT "$PORT
 
cd /path/to/$PROJECT
sh /path/to/local-setup.sh
 
git init
git remote add deploy ssh://root@$IPSERVER$SRV/git/$PROJECT.git/
 
git add . 
git commit -m "<commit message>"
git push deploy master
 
# open browser http://$IPSERVER:$PORT/ 
# open browser http://$IPSERVER:5554/