To expedite delivery almost every
project has merged their Development and Operational activities under a common
pipeline. The philosophy has been implemented in different way by keeping DevOps
principles intact across the globe. Simplicity and Security is one of the most
important aspect of DevOps Principals. It reduces operational overhead and
improves Return of Investment.
Keeping that in mind I preferred
to use GitLab which provides everything that is essentials for DevOps lifecycle.
Every commit gets tested rigorously, then Build image and deploy in Docker
Swarm or in Kubernetes cluster. GitLab delivers every feature very quickly to
the end-user.There are various ways to achieve that. Continuous deployment
usually gets configured through webhooks. A common pattern is to run http
server locally that listens incoming HTTP requests from repository and triggers
specific deployment command on every push.
Instead of using BaseHTTPRequestHandler
to listen incoming request I used gRPC to call function defined in server side.
gRPC claims 7 times faster that REST when receiving data & roughly 10 times
faster than REST when sending data for a specific payload.It has many other
advantages, like
·
Easy to understand.
·
Loose coupling between clients/server makes
changes easy.
·
Low latency, highly scale-able, distributed
systems.
·
language independent.
Enough talking, lets jump into the actual implementation.
The design is very simple,
- Run a gRPC server inside the controller system.
- Write a simple bash/shell script comprising specific deployment command
- Run gRPC client in pipeline on every push
My gRPC hook:
gRPC uses Protocol Buffers as the
interface description language, and provides features such as authentication,
bidirectional streaming and flow control,blocking or non blocking bindings, and
cancellation and timeouts.Protocol Buffers is the default serialization format
for sending data between clients and servers.
Lets define a protobuff :
Using
above description grps_tools will generate two classes _pb2_grpc.py and _pb2.py. Run the following command and generate gRPC classes.
$ python
-m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. glb_hook.proto
Along with simplicity we must consider security. Therefore,
generate self-signed certificate.
$ openssl
req -newkey rsa:2048 -nodes -keyoutserver.key -x509 -days 365 -out server.crt
For more details visit gRPC documentation page and generate Server & client code.
Create deployment script and put that in same directory
where gRPC server run
Configure client inside CI/CD to call deployment script
remotely on every push. Once pipeline is ready, start server
$ nohup
python server.py &
At this point, every commit and push into the repository,
pipeline will execute jobs.
Once client calls the function (that is defined inside the server) with a valid string value (command), a new process will be opened at server
side, which is in this case, the script test.sh. If we have a look in to the
server, we found Docker command pulling latest image and executing them in
detach mode on a specific port. Once deployment is done, hit the URL and we'll see the change.
