Few days ago, I was setting up nginx reverse proxy for my project. I was using gunicorn for the HTTP Server with flask-restx for the web framework. Actually this was the first time for me using this combination. I usually use uwsgi for the deployment.
It was quite simple to deploy flask with gunicorn. You can use port binding.
After finishing the configuration and testing the service, although I could access all function of the web service, I found out a problem when accessing the documentation.
The documentation page was still getting the swagger data from localhost, because we only set the reverse proxy option to the project.
Then, I realized that we have to config the proxy header also inside the configuration, so the documentation page will request the data from the domain we setup, instead of localhost. So this is my nginx configuration now.
We use proxy_set_header Host $host to set the proxy request to same name as the server_name directive, so it will request the domain name, not the original host where we deploy the service.
I also use proxy_set_header X-Forwarded-Proto $scheme because I am using SSL for the domain. If you don’t use that option, the request will be blocked, because of mixed content issue (domain with SSL request to non SSL domain).
Then, after adding that two lines and restarting the service, we can load the data from the swagger 😁
Well, maybe this is all I can share. If you found any problem when using gunicorn and flask restx with nginx as reverse proxy, you can try this solution. Thank you!
Few weeks ago, my office had a sharing session. My friend shared how he created a tinder bot to do automatic swiping using selenium. Actually the main point of the presentation is how to use selenium (GUI or script) to finish your daily tasks automatically. But, I was interested with the tinder bot. I though, instead of doing mass swiping to the right or left, we can choose whether he/she is based on our preference or not. If he/she is based on our preference, then swipe right.
After googling some materials, I found some projects about beauty facial prediction, but all projects mostly used SCUT-FBP5500 dataset. The SCUT-FBP5500 dataset has totally 5500 frontal faces with diverse properties, labelled by 60 volunteers. But, what I want to do is to predict the image based on my preference, not by others.
Then, I found this BeautyPredict. This project is quite simple. I tried to understand the process: preparing the data, training, predicting the score, and of course the dataset pattern. After understanding the process, finally I have 2 tasks to be done:
Create the dataset tool.
Refactor the BeautyPredict because there are some deprecated function.
Create the dataset tool
I am using flask to build the web app. And, because i am not good at design, thanks to adminlte for helping me with the design. Of course, it is mobile friendly.
And for images data, I have around 3000 face data in my storage, actually I got that data from my research few years ago. Finally, that data has a purpose!
Refactor the beauty predict
Although the project is quite simple, but there are some deprecated functions, so it will be failed if we run it with newer version of the python libraries.
Time to predict
After labeling around 1000 images, I tried to process the images and training the data, then I picked random image from instagram and predict it, it’s quite good and actually the result was as I expected.
Sorry, I have to blur the image 😛
Conclusion
So, with this project, we can rate someone whether he/she is based on our preference. If you want to know more about how the system score the image, you can visit the BeautyPredict project on Github.
And I just want to say this on the conclusion, that I believe, all men are handsome and all women are beautiful, but all people have their own preference.
Anyway, this was just my weekend research and it is not finished yet, so I didn’t write the complete instruction. But if you want to know more about the project, you can visit here.
The most important thing when building the web API is creating API documentation. With API documentation, it will be easier for another programmer to integrate their application with your web service.
In this post, I will show how to integrate Go net/http package and swagger using http-swagger package.
Installation
First, we have to install swag package.
$ go get github.com/swaggo/swag/cmd/swag
Initialization
Then we have to generate first `docs` folder, so we could import it to the application. Please run it on root folder of the project.
$ swag init
After generate docs folder, we import the package and generated docs. In this case, my project name is goweb.
We have to initialize the general info for the documentation. It will be placed before main function. It describes the name, description, contact, etc. For the detail, we could see from the swag documentation.
// @title Go Restful API with Swagger
// @version 1.0
// @description Simple swagger implementation in Go HTTP
// @contact.name Linggar Primahastoko
// @contact.url https://linggar.asia
// @contact.email x@linggar.asia
// @securityDefinitions.apikey ApiKeyAuth
// @in header
// @name Authorization
// @host localhost:8082
// @BasePath /
func main() {
...
}
We add these blocks to tell swagger that we will be using token in header for the authentication. So it means, if we want directly access some pages that using authentication, we have to pass Authorization: Basic xxxyyytokenzzzaaa
We will write the documentation on each function and placed before the function itself. For the parameter and response, we just have to write the struct name on the documentation because we already have defined the structs. This is the part I like the most, because we don’t have to define the structure again in the documentation part.
That is the login function, so we don’t have to pass the token to access the resource. But what if we want to authorize with token in swagger? Yes, we only have to add // @Security ApiKeyAuth.
After we setup all the components, we have to generate the documentation with swag command again.
$ swag init
2019/01/29 20:29:34 Generate swagger docs....
2019/01/29 20:29:34 Generate general API Info
2019/01/29 20:29:34 Generating main.authParam
2019/01/29 20:29:34 Generating main.authResp
2019/01/29 20:29:34 Generating main.meResp
2019/01/29 20:29:34 create docs.go at docs/docs.go
Finally, we could build and run the application. We could access the documentation in http://<host>:<port>/swagger/index.html.
Example
This is the full implementation to integrate swagger with Go net/http package. This is only an example. It is not a perfect code that you could just copy and paste into your web app, because actually, we could write with better handler, wrapper, and middleware. For the detail of username, password, and token, you could get that information from the code. So, please enjoy! 😀
main.go
package main
import (
"encoding/json"
httpSwagger "github.com/swaggo/http-swagger"
"log"
"net/http"
"strings"
_ "goweb/docs"
)
type errorResp struct {
Error string `json:"error"`
}
type indexResp struct {
Message string `json:"message"`
}
type meResp struct {
Username string `json:"username"`
Fullname string `json:"fullname"`
}
type authResp struct {
Token string `json:"token"`
}
type authParam struct {
Username string `json:"username"`
Password string `json:"password"`
}
// writeJSON provides function to format output response in JSON
func writeJSON(w http.ResponseWriter, code int, payload interface{}) {
resp, err := json.Marshal(payload)
if err != nil {
log.Println("Error Parsing JSON")
}
w.Header().Set("Content-type", "application/json")
w.WriteHeader(code)
w.Write(resp)
}
// basicAuthMW is middleware function to check whether user is authenticated or not
// actually you could write better code for this function
func basicAuthMW(w http.ResponseWriter, r *http.Request) map[string]string {
errorAuth := errorResp{
Error: "Unauthorized access",
}
header := r.Header.Get("Authorization")
if header == "" {
writeJSON(w, 401, errorAuth)
return map[string]string{}
}
apiKey := strings.Split(header, " ")
if len(apiKey) != 2 {
writeJSON(w, 401, errorAuth)
return map[string]string{}
}
if apiKey[0] != "Basic" {
writeJSON(w, 401, errorAuth)
return map[string]string{}
}
users := map[string]map[string]string{
"28b662d883b6d76fd96e4ddc5e9ba780": map[string]string{
"username": "linggar",
"fullname": "Linggar Primahastoko",
},
}
if _ , ok := users[apiKey[1]]; !ok {
writeJSON(w, 401, errorAuth)
return map[string]string{}
}
return users[apiKey[1]]
}
func decodePost(r *http.Request, structure interface{}) {
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(structure)
if err != nil {
log.Println("Error parsing post data")
}
}
// authLogin godoc
// @Summary Auth Login
// @Description Auth Login
// @Tags auth
// @ID auth-login
// @Accept json
// @Produce json
// @Param authLogin body main.authParam true "Auth Login Input"
// @Success 200 {object} main.authResp
// @Router /auth/login [post]
func authLogin(w http.ResponseWriter, r *http.Request) {
var param authParam
decodePost(r, ¶m)
if param.Username == "linggar" && param.Password == "linggar" {
respAuth := authResp{
Token: "28b662d883b6d76fd96e4ddc5e9ba780",
}
writeJSON(w, 200, respAuth)
} else {
failResp := errorResp{
Error: "Wrong username/password",
}
writeJSON(w, 401, failResp)
}
}
// userProfile godoc
// @Summary User Profile
// @Description User Profile
// @Tags users
// @ID user-profile
// @Accept json
// @Produce json
// @Success 200 {object} main.meResp
// @Router /users/profile [get]
// @Security ApiKeyAuth
func userProfile(w http.ResponseWriter, r *http.Request) {
info := basicAuthMW(w, r)
if len(info) == 0 {
return
}
respMe := meResp{
Username: info["username"],
Fullname: info["fullname"],
}
writeJSON(w, 200, respMe)
}
// @title Go Restful API with Swagger
// @version 1.0
// @description Simple swagger implementation in Go HTTP
// @contact.name Linggar Primahastoko
// @contact.url https://linggar.asia
// @contact.email x@linggar.asia
// @securityDefinitions.apikey ApiKeyAuth
// @in header
// @name Authorization
// @host localhost:8082
// @BasePath /
func main() {
http.HandleFunc("/swagger/", httpSwagger.WrapHandler)
http.HandleFunc("/auth/login", authLogin)
http.HandleFunc("/users/profile", userProfile)
http.ListenAndServe(":8082", nil)
}
When I setup the kubernetes at the first time, after execute kubeadm init and apply the pod networks plugin, flannel or calico, I see that the master status is not ready.
linx@node-1:~$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
node-1 NotReady master 3m44s v1.13.0
After reading some articles, I found out that we also need apply weave-kube plugin. I try to apply weave kube plugin, then the master status becomes ready 😀
linx@node-1:~$ kubectl apply -f https://git.io/weave-kube-1.6
serviceaccount/weave-net created
clusterrole.rbac.authorization.k8s.io/weave-net created
clusterrolebinding.rbac.authorization.k8s.io/weave-net created
role.rbac.authorization.k8s.io/weave-net created
rolebinding.rbac.authorization.k8s.io/weave-net created
daemonset.extensions/weave-net created
linx@node-1:~$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
node-1 Ready master 8m55s v1.13.0
