Configuration and secrets

before we start configuring our server and see the results of our work i want to introduce a way

so we can configure certain settings based on the environment that our application is is running in

right now our application assumes a few things it assumes what host it should run on what port

to listen to what environment is running in and we've been hard coding some of these values in

different places i want a specific place that these values get set and defined so we can reuse

them throughout the application this comes in handy when we start to add more things like

secrets like database credentials or hashing keys and things that we don't want in our source code

right now the environment settings that we have are rather limited we will be able to configure

the app host the port the environment

and the project name and this will all be done through environmental variables now for the

unfamiliar you can think of environmental variables as pieces of configurations that live

outside of your app in your in your operating system they let you change settings without

adding the code and this is very useful when we go from development to testing to production

so for example on your own computer you can have environmental variables set in your terminal and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

then you can add them to your own application and then you can add them to your own application and

the environmental variable that we that it should look for is gonna be uppercase

app underscore and then uppercase host then we can copy all of this paste it

down here and then we just need to chain host to port so we have added these

structures what struct tags that specify a different name compared to the field

name and this is more of our convention but it's also to tell the parser that

we're going to add in just a second the the name of the environmental variables

it should look for so now let's specify a new function here so we can actually

create a config say config or error

say cfg which is just config for short create a empty config struct then we're

going to be using a package now called env where we can say pass bit options

you're gonna pass a pointer to the cfg and cfg variable and then we're gonna

say env.options it's just gonna be empty for now and then we're gonna say cfg.options and then we're gonna say cfg.options it's just gonna be empty for now and then we're gonna say cfg.options it's just gonna be empty for now and then we're gonna say cfg.options it's just gonna be empty for now

close that and if the error is not nil simply simply return the error and if

we have no errors we return the config and nil I'm gonna give that a save and

we're gonna have an error here because we're gonna be using this package from

Carlos Zero called env so let me just add this to our go.mod file and if I

restart the LSP it should go away

great and of course we also need to turn an empty config struct if there is an

error now this this package is really really handy and we can specify options

like if an env variable should be required or not so that we actually get

an error if it can't find that env variable so we don't start running our

application without all the expected environmental variables in place now we

have set up our config struct with app host and port but I also mentioned that

we wanted to have environment and project name these values are used

throughout the application and sometimes in places where it can be ordered to

pass an argument like like in our views for example therefore I tend to make

these these global in a sense that we simply expose them directly through the

config package now you should not use global as a general rule of thumb they

make the code harder to test and they can change unexpectedly in this case we

have a limited set of values and we can provide same defaults so we're not

really risking shooting ourselves in the foot for everything else like host port

database credentials whatever we will stick to the to the config struct so

values are explicit and testable we have two environments we have development and

we have production so I want to make sure that we have these as const and we

can then check against these these variables or values throughout the

application so I'm gonna say const dev environments equal to development const

prod environments

environment and it's gonna be equal to production and then I want to use this

get env method from the OS package to look up the value and then we're simply

just gonna return the dev environment if it's not set so to do that we're gonna

create a variable that's gonna be called env consider that equal to our function

that returns a string we're just gonna immediately call that function so if

OS get env and it's gonna be environment in all other case that's not

equal to an empty string then we simply say oh there we go return that value go

and if not then we're gonna return dev environment give that a save and now we

can do the same but for project name so I'm just gonna copy all of this past it

below say project name project name there we go and here we can also provide

a default if you don't want this to be called bleeding yes for example you can

overwrite it but we're gonna be defaulting the project name to be leading edge

All right. Now, the final thing we need to do is we need to add a .env file that will hold these variables.

And the .env is more like a convention rather than a requirement.

You can call it whatever, but a lot of tools will actually look for .env files.

That's why we are going to name it like that.

So I'm in the .env file here, and we're just going to add the .env variable.

So I'm going to say export app host.

It's going to be local host.

Then we're going to say export app port.

I'm going to set it to 8080.

And then we're going to say export environments equal to developments.

And then file.

Finally, export project name.

And I'm going to set it to bleeding.

Again, feel free to overwrite this if you want the block to be called something else.

Now, to actually have these variables in our terminal, we need to source them.

And that is also why I have put this export keyword in front of the variable names.

And this is because Go doesn't automatically load these .env files.

Later on, we will add a tool that will handle this for us automatically.

But for now, we need to go into the terminal and write source space .env.

And then these variables, .env variables, will be set in the terminal.

And finally, I want to show you one more benefit of having all of our .env or environmental variables live on a struct.

And that is we can add methods to this struct to make our life easier.

For example, we are going to be needing a txt.

tcp address that we are going to use for running our server.

And that is going to be a combination of app host and app port.

So to do this, we can simply just add a method, config, and say get tcp adder.

It's going to be a string.

And now we can return fmt, sprintf.

We're going to say as.

And then.

We're going to say app host and app port.

Give that a save.

And now we have all in place so we can finally configure our server and our entry point and start actually running this application.