Deploying a gRPC service to Sevalla

Hey folks, so today we're going to walk through how to deploy our gRPC applications on Sevalla.

So Sevalla is a really nice new platform in which you can host your applications and it takes all the complexity out of deployments, allowing you to just focus on writing the code itself. The great thing about Sevalla is it will build and deploy your applications for you, whilst also managing things like networking, so the service will be automatically exposed to the internet if you wish.

It also integrates with both GCP and Cloudflare, so you get performance benefits from being able to deploy around the globe, and it also gives you things like DDoS protection out of the box.

What's really nice is if you sign up to Sevalla, you get $50 worth of free credits too. So in this video today, we're going to walk through how to deploy our gRPC applications, both directly from a Git repo and also from Docker as well, as Sevalla supports both. And we're going to do that using a Hello World application that we've seen in previous videos. So this is just the same as what we've seen before.

It's just a standard say hello RPC that takes a name in a request and... return to message as a response and the implementation is the same as we've written in previous videos as well. I've created a client and a server what we'll do is we'll deploy the server directly through the git repo and then after that we'll deploy the client application using Docker just to demonstrate how to do both. So in the server it's just the same as what we've seen previously there's one difference and that's that we're using this port environment variable so this is something that Sevalla sets by default it will say this to port 8080 so we're going to use this and we're going to listen on whatever port is provided in this environment variable so for the server application we're going to deploy directly from our git repo so with Sevalla you can integrate with GitHub and anytime you make a commit and push a commit to the remote repo it will automatically build and deploy that code for you there's one thing to note when doing this kind of deployment Sevalla expects the main.go file to be in the root directory and not in a different directory.

So that's one thing that we'll have to change in our project, but besides that, everything else should be fine. And now once we've set it up, once we push a commit, it will automatically build and deploy for us. So let me just open a terminal and I will push that change. So let me change. Move main.go file to root directory and now let me push that as well.

So now if I go to the browser, I can go to GitHub and I can show the repository. So we have this repository here that just has the main.go file in the root and now let's go to Sevalla and we'll create an application and get that deployed for us. If I just go to the dashboard, I go to deploy an application and now I can select git repository here and it supports both private or public repositories. I'm actually logged in using GitHub so I should have access to my private repositories.

select here the repo that I want to deploy and also the branch I want to deploy from and then by checking this anytime a change is pushed to that branch it should automatically deploy. We'll name the application just the same as the git repo and then for the location because I'm based in London let's just set to London for our location but this we could deploy in any region that GCP supports. It's worth deploying whatever is closest to your users but yeah for me to go for London for this video and then finally you can choose how many resources you want so for this example we'll just go for the smallest amount of cpu and smallest amount of ram that we can but of course depending on how many users you've got and how much throughput your application will have you this might change for the very basic the hobby uh smallest instance this would be five dollars a month but as i said because we have that 50 credit it should be okay so now we can click create and deploy and this should all build our application and deploy it. So now we can see the logs where it's cloning our repo and it should start building the Go application.

What's nice is you can see exactly what it's doing and what it's building during this process and it gives you all the deployment logs and then once it's built running you can see the runtime logs as well which I'll show just once this is running. So now as you can see here it's actually running the go build command to build our application.

So now it looks like docker image has been built and pushed to their registry so now it's going to deploy our application using that docker image and now we can see our log as well so this is the runtime log saying that the gRPC server has started and I'll just zoom in a little bit so it's easier to see and you can see it started on address 8080 so by default that port environment variable is set to 8080 but we can configure that as well and then as I said before we can see in the runtime logs have our log to save the server started and that's what we can see from this logs page here as well what's really nice about Sevalla is we obviously can see all the runtime logs here so we don't have to set up any of that ourselves they automatically just get pushed and they're visible in the dashboard and also we get like this analytics page as well with like memory and cpu usage and requests per minute and response time things like that which is really nice because if we were just to deploy this on kubernetes we'd have to configure like other instrumentation around our application to get this information and then we can configure things like the environment variables here as well so for example if we wanted to change that port to 50051 we can do that and we just save that and now now when one thing to note is when you do change environment variables it doesn't automatically deploy your changes so we'll just click deploy changes and that will rerun our application with environment variable. We'll just look at the Inflip deployment and see when it starts.

So now the image is rebuilt and now it should be deployed as well. So it looks like it takes roughly two minutes to deploy a Go application by building the docker image and it looks like it's actually deployed. on 8080 again let me just double check why that is so I just go back to Golan and see if there's a bug in the code somewhere and actually I think I've noticed what the problem is this is my mistake the port needs to be configured on the networking tab not directly the environment variables so by setting it here it automatically will set the port environment variable but yeah it looks like it can't be set as part of the environment variables needs to be set explicitly here. Let me just change that and redeploy it and actually i'm going to cancel that and just redeploy by skip app building as that will be quicker.

And now it looks like it's deployed, so let's see what the logs say. And now this time we can see that it is deployed on the correct port on 50051. So that's how we can configure the port if we wanted to change it as well. The other really great thing that Sevalla does for us that I mentioned at the beginning was that it configures all the ... networking for us and it exposes the application without us having to do any additional configuration or without having to create any additional resources and it gives us a domain name here so we can access it publicly. This obviously can be disabled so if you don't want to expose your applications you don't have to. It's really great that it does that for you and also you can set up private networking so if you want to connect to this service from a different application in your...

in your projects then you can also use this domain name this host name instead and that's just exposed inside your inside the cluster so just to prove that this is now exposed to the world we'll grab this host name and we'll make a call from postman and also use our client code to to call this and one other thing you can do is you can actually set your own custom domains so we won't do that in this video but um yeah you can actually configure your own custom domains and configure it to expose on whatever domain you would like. So now let's go to postman and we can actually make a request to the server and see if we get a response. So I'll just set the hostname that we copied from the dash in here and this is our say hello RPC so we're gonna pass our name my name is Chris in the request and we should get a response of hello Chris. and it seems like we're getting an error so there may be something else we need to configure before this will work and we actually need to change the protocol as well so by default it says the protocol to HTTP which would be fine for like a restful a regular restful service but for this we want to use gRPC so we just need to update the protocol here and this will expose it as a gRPC service.

And now if we go back and try again, maybe this takes a little while to propagate. And there you go. This time we get a response. And just to prove that this is working as we expect, we can set a different name in the request. So let's just write some other name and when we hit the server with that, we get the correct message back as well. So that's it. easy it is to deploy a server application by directly integrating with the git repository so now let's deploy another application which will contain a gRPC client and we'll use Docker for that so we'll build it ourselves we'll build a Docker image we'll push it to our GitHub packages registry and then we'll use that to deploy on Sevalla so in this client we're spinning up a HTTP server which just has a single endpoint in the root and that will make the say hello rpc call to our server so the first thing we're doing is we are checking in our variable called gRPC_HOST and this will get the host name for our server so this is where we'll pass the the domain name that our server application has and then we're initializing a gRPC connection to that host and we're creating it with tls with server-side tls so that's another thing that we get by default from using Sevalla. When we deploy, they automatically handle the server-side TLS for us. So although our application, our server-side application doesn't have any certs, doesn't load any certs or anything like that, but by the time it's exposed publicly, it does have TLS enabled, which is really nice. So here we're just passing in an empty TLS config, just because we're not using MTLS, we don't need to provide any other certs. That's how we configure our gRPC connection and then we'll we're creating our hello service client and then after that in the rest endpoint that we're creating we're just making a say hello request and then we're just writing the message that we get back in the response we're returning that to the client just so we can demonstrate how this works when it's deployed and as before we're checking this port environment variable which is set by default by so far so let's out by building the application so i provided a Dockerfile here as well and this basically just builds the the client application so it builds the the main.go file from here it copies the binary into a separate base image and then it will just run the binary when it starts.

so to build this we'll run docker build and we'll give it a tag of github container registry and then my github username and then the name of the git repository which is gfc hello world Sevalla and then we'll call it client and now they should build our application and tag it with that tag so that's built let's push that image so it's because we haven't set a tag it's going to set it to latest and that's that's pushed now to our registry so if we go back to github we can see it in our packages here and the latest one was pushed less than a minute ago and that's the latest so now copy the image name and if we go back to Sevalla we'll create a separate application and we'll use docker image this time provide the docker image path and if you're using a private registry or a private git repository you'll need to provide credentials as well so it can actually pull the image this is something I've already added but you can add this by going to your user settings and add it add the github token in there and now let's name our application so let's just name this client and we'll deploy it in the same place as the server side application in london and then we'll set the resources to be the lowest ones again just as the hobby resources just because we don't need a lot of resources for this application and now we can do create and deploy and actually whilst we wait for that to deploy I'll just demonstrate how to actually run the client locally and demonstrate it actually calling that server. The environment variable we're using for the host name is called gRPC_HOST so in there we just provide the host name and I'll just copy it from postman. So we'll provide the host like that and then we'll do go run cmd slash client slash main.go and you can see that now the gRPC host is set to this and it's running on port 8080. So if I go to postman I can demonstrate but this is working as we expect by hitting local host 8080 and you can see we got our response back so this is the response message that the gRPC server returned to our service that we're running locally and then we just sending that back to the client so that's why when we deploy our application on Sevalla we should hopefully see the same response so now if I go back to here and hopefully it's deployed and it looks like it has deployed so the gRPC_HOST is by default set to localhost 50051 so that was just what we were setting it to if that environment variable wasn't set but we will actually set this environment variable in Sevalla now And let's just go to Postman and copy the host name again. And now we'll redeploy with the new changes. See the deployment log. here and once it's deployed it should log the new gRPC host so it looks like it's created a http server on port 8080 so now if we go to networking and we check the protocol so for this we want http as the protocol that's what we're set to and now our application should be exposed at this hostname Now when I make a request to this, it should first hit our client application, which will then make a gRPC call to our server application and then return the response. And you can see we got Hello Chris back from our server.

and if you just want to get your application up and running as quick as possible and ship it as quick as possible this is definitely a good choice for that so with that I hope you enjoyed this