DEV Community: Reishi Mitani

Getting started with wolfssl

Reishi Mitani — Fri, 23 Sep 2022 09:09:05 +0000

First, clone the repository. This is going to take some time.

git clone https://github.com/wolfssl/wolfssl
Cloning into 'wolfssl'...

// will take a few minutes

Enter the directory and run autogen

$ cd autogen.sh
$ sh autogen.sh
glibtoolize: putting auxiliary files in AC_CONFIG_AUX_DIR, 'build-aux'.
glibtoolize: copying file 'build-aux/ltmain.sh'
glibtoolize: putting macros in AC_CONFIG_MACRO_DIRS, 'm4'.
glibtoolize: copying file 'm4/libtool.m4'
glibtoolize: copying file 'm4/ltoptions.m4'
glibtoolize: copying file 'm4/ltsugar.m4'
glibtoolize: copying file 'm4/ltversion.m4'
glibtoolize: copying file 'm4/lt~obsolete.m4'
configure.ac:22: installing 'build-aux/compile'
configure.ac:24: installing 'build-aux/config.guess'
configure.ac:24: installing 'build-aux/config.sub'
configure.ac:28: installing 'build-aux/install-sh'
configure.ac:28: installing 'build-aux/missing'
Makefile.am: installing 'build-aux/depcomp'
parallel-tests: installing 'build-aux/test-driver'

After finishing, run the following.

$ ./configure
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
....
   * IoT-Safe:                   no
   * IoT-Safe HWRNG:             no
   * NXP SE050:                  no
   * PSA:                        no

---

$ make check
/Applications/Xcode.app/Contents/Developer/usr/bin/make -j17  check-recursive
make[2]: warning: -jN forced in submake: disabling jobserver mode.
  CC       wolfcrypt/src/src_libwolfssl_la-hmac.lo
  CC       wolfcrypt/benchmark/benchmark.o
....
/Applications/Xcode.app/Contents/Developer/usr/bin/make -j17  check-TESTS
make[3]: warning: -jN forced in submake: disabling jobserver mode.
make[4]: warning: -jN forced in submake: disabling jobserver mode.
SKIP: scripts/openssl.test
SKIP: scripts/external.test
PASS: testsuite/testsuite.test
PASS: scripts/resume.test
PASS: scripts/google.test
PASS: scripts/tls13.test
PASS: scripts/unit.test
============================================================================
Testsuite summary for wolfssl 5.5.0
============================================================================
# TOTAL: 7
# PASS:  5
# SKIP:  2
# XFAIL: 0
# FAIL:  0
# XPASS: 0
# ERROR: 0
============================================================================

Finally, install the library.

sudo make install
Password:

We can try out sample samples as below.

// In one window
$ ./examples/server/server

// In another
./examples/client/client

Using software like Wireshark, we can see that the server and the client are talking to each other using encrypted data.

Transmitting a sine wave from Matlab to Pluto

Reishi Mitani — Thu, 03 Feb 2022 06:16:38 +0000

I recently had to configure my Matlab code to send a sine wave to Adalm Pluto. I set the gain to -1 and the frequency to 2.4 GHz. I am pausing the code so that I can check the pulse on my spectrum analyzer.

Below is the code that I used.

deviceNameSDR = 'Pluto'; % Set SDR Device
radio = sdrdev(deviceNameSDR);           % Create SDR device object

txGain = -1;

% sdrTransmitter = sdrtx(deviceNameSDR); % Transmitter properties
% sdrTransmitter.RadioID = 'usb:0';

tx = sdrtx(deviceNameSDR);
tx.RadioID = 'usb:0';
tx.CenterFrequency = 2.415e9;
tx.BasebandSampleRate = fs;
tx.Gain = 0;

fs = 2e6;
sw = dsp.SineWave;
sw.Amplitude = 100;
sw.Frequency = 2.432e9;
sw.ComplexOutput = true;
sw.SampleRate = fs;
sw.SamplesPerFrame = 20000; 
txWaveform = sw();

transmitRepeat(tx,txWaveform);

pause(60)

release(tx);

The pulse looks like below.

I connected Pluto to my PC and my spectrum analyzer.

Creating a simple local server from scratch using node and express

Reishi Mitani — Sun, 15 Nov 2020 14:24:38 +0000

Objectives

Create a local server on your machine using node.js We will first create a simple app that shows hello world and then use express.js for routing. Finally, we will create some APIs and route them.

Prerequisites

Mac OS Catalina

Create an app with a simple local server that returns Hello World

// create your own directory
$ mkdir node-practice && cd node-practice
// initialize your project
$ npm init -y
// create your app.js
$ touch app.js
$ vi app.js

Edit your app.js.

const http = require('http');
const server = http.createServer((req, res)=>{
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World!');
})
server.listen(8080);

Run the command below, and access localhost:8080. You should see Hello World appear in the page.

$ node app.js

Introducing express

We will install express.

$ npm install express -save

Create our public folder

$ mkdir public && cd public
$ touch index.html
$ mkdir css img js

Your folders should look like this now, excluding the node_modules.

$ tree -I node_modules
.
├── app.js
├── package-lock.json
├── package.json
└── public
    ├── css
    ├── img
    ├── index.html
    └── js

4 directories, 4 files

We will create the following files inside each of our files.

node-practice/public$ cd css && touch sample.css
node-practice/public$ cd js && touch sample.js

I will have a sample photo inside my img folder.

So now your folders should look like this.

$ tree -I node_modules
.
├── app.js
├── package-lock.json
├── package.json
└── public
    ├── css
    │   └── sample.css
    ├── img
    │   └── sample.jpeg
    ├── index.html
    └── js
        └── sample.js

4 directories, 7 files

For our index.html:

<!DOCTYPE html>
  <head>
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <title>TEST</title>
    <link rel="stylesheet" href="/css/sample.css">
  </head>

  <body>
    <h1>Hello World!</h1>
    <p id="hoge"></p>
    <div>
      <img src="/img/sample.jpeg">
    </div>
    <script src="/js/sample.js"></script>
  </body>
</html>

For our sample.js:

/* /public/js/sample.js */
{
  const el = document.getElementById('hoge');
  el.innerText = 'HAHAHAHAHAHAHA!!!!';
}

For our sample.css:

/* /public/css/sample.css */
h1 {
  font-size: 1.5rem;
  color: #0000ff;
}
img {
  max-width: 100%;
}

Edit our app.js

const express = require('express');
const app = express();
const path = require('path');

app.listen(8080, () => {
  console.log('Running at Port 8080...');
});

app.use(express.static(path.join(__dirname, 'public')));

app.use((req, res) => {
  res.sendStatus(404);
});

When you run the following, you should see the web page on localhost:8080.

$ node app.js

Create our APIs

We will create our apis, by creating a folder first.

// at the root directory of the project.
$ mkdir api && cd api
$ touch data.json index.js

We will create some random data in data.json:

{
  "id": "W0001",
  "title": "I Love Cats and Dogs",
  "price": 3000000000000
}

For index.js, we export our api router.

const express = require('express');
const router = express.Router();

router.use(express.json());

router.get('/foo', (req, res) => {
    res.sendFile(__dirname + '/data.json', (err) => {
        if (err) {
            res.sendStatus(400);
        } else {
            console.log('completed');
        }
    });
});

router.route('/bar')
    .get((req, res) => {
        res.json(req.query);
    })
    .post((req, res) => {
        const nameArray = ['id', 'name', 'address'], failed = nameArray.some(v=>!req.body[v]);
        if (failed) {
            res.sendStatus(400);
        } else {
            res.sendStatus(200);
        }
    });

module.exports = router;

Our folders should look like this now.

$ tree -I node_modules
.
├── api
│   ├── data.json
│   └── index.js
├── app.js
├── package-lock.json
├── package.json
└── public
    ├── css
    │   └── sample.css
    ├── img
    │   └── sample.jpeg
    ├── index.html
    └── js
        └── sample.js

5 directories, 9 files

Now, we will edit our app.js in our root directory.

const express = require('express');
const app = express();
const path = require('path');
const api = require('./api/');

app.listen(8080, () => {
    console.log('Running at port 8080...');
});

app.use('/api', api);
app.use(express.static(path.join(__dirname, 'public')));

app.use((req, res) => {
    res.sendStatus(404);
});

Now, we run node app.js.

Testing the APIs

Let's use Advanced REST Client to see how the APIs are working.

When we throw http://localhost:8080, we get the following result.

When we throw http://localhost:8080/api/foo, we get the data.json.

When we throw http://localhost:8080/api/bar?name=johndoe&address=USA&age=17, we get the json from the URL values.

Finally, let's POST some data using the bar api. We can add it by editing the body parameters.

Now we can see that the APIs are working, both GET and POST!

Hope this helps.

Set tab to 4 spaces in vim

Reishi Mitani — Wed, 11 Nov 2020 00:30:04 +0000

Create or edit .vimrc in your default directory.

// go back to your root directory
$ cd
// create or edit .vimrc
$ vi .vimrc

// inside .vimrc, add the line below
set tabstop=4

Downloading Ubuntu onto Mac VirtualBox

Reishi Mitani — Thu, 05 Nov 2020 06:54:14 +0000

Prerequisites

Already have VirtualBox installed.

Procedures

Access the website for Ubuntu and click download: website for Ubuntu

The iso file is about 3 GBs.

We will create a new VM once the file is downloaded.

We will name the VM Ubuntu-ns3, since I want to install ns3 later.

We will allocate 1024MB of memory to the VM.

Select create virtual hard disk.

Select VDI.

Select fixed size for storage on the hard disk.

I allocated 40GB for the size. The default is 10GB.

Now once we are back on this page, we press start.

Select the file we previously downloaded.

Follow the orders below.

Choose English as your language.

Choose normal installation.

Choose erase disk and install Ubuntu.

Press continue.

After you choose your location, the following should appear.

Wait a few minutes while the OS is being installed.

Finally, the welcome page will appear.

Mini gRPC Project (2): Deploying the gRPC API on k8s

Reishi Mitani — Fri, 16 Oct 2020 02:05:28 +0000

This is part 2 of Mini gRPC Project (1): Creating a Simple Increment API on Go

Prerequisites

MacOS Catalina
Already have gopaths configured
Have a GCP project of your own

Overview of the Directory

$ tree
.
├── README.md
├── infrastructure
│   ├── backend-deployment.yml
│   ├── backend-service.yml
│   ├── frontend-deployment.yml
│   └── frontend-service.yml
├── proto
│   ├── calc.proto
│   └── gen
│       └── calc.pb.go
└── src
    ├── backend
    │   ├── Dockerfile
    │   └── main.go
    └── frontend
        ├── Dockerfile
        └── main.go

6 directories, 11 files

Create Dockerfiles

`src/frontend/Dockerfile`

Make sure to push your protos to your github account so that you can import them.

FROM golang:1.15

ENV HOME /root
ENV PATH $PATH:/usr/local/go/bin
ENV GOPATH /go 
RUN echo $GOPATH
RUN go get -u github.com/golang/protobuf/protoc-gen-go
RUN go get -u github.com/grpc-ecosystem/go-grpc-middleware/logging/zap
RUN go get -u go.uber.org/zap
RUN go get -u github.com/YOURACCOUNT/micro-prac/proto/gen
WORKDIR /go/src/micro-sample-frontend
COPY . .

RUN go build -o /usr/local/bin/micro-sample-frontend

CMD ["micro-sample-frontend"]

`src/backend/Dockerfile`

FROM golang:1.15

ENV HOME /root
ENV PATH $PATH:/usr/local/go/bin
ENV GOPATH /go 
RUN echo $GOPATH
RUN go get -u github.com/golang/protobuf/protoc-gen-go
RUN go get -u github.com/grpc-ecosystem/go-grpc-middleware/logging/zap
RUN go get -u go.uber.org/zap

# Make sure to push your protos to your github account
RUN go get -u github.com/YOURACCOUNT/micro-prac/proto/gen

WORKDIR /go/src/micro-sample-backend
COPY . .

RUN go build -o /usr/local/bin/micro-sample-backend

CMD ["micro-sample-backend"]

Create the Docker Images

To build, use the following command.

docker build -t gcr.io/$PROJECT_ID/micro-sample-frontend:v0.1 .
docker build -t gcr.io/$PROJECT_ID/micro-sample-backend:v0.1 .

Create GCP project

I created a project and in my GKE created a cluster called micro-sample.

In my local machine, we will run the following

$ gcloud init
Welcome! This command will take you through the configuration of gcloud.

// Choose the correct configurations for your project.
.......

$ gcloud container clusters get-credentials micro-sample --zone="asia-northeast1-a"
Fetching cluster endpoint and auth data.
kubeconfig entry generated for micro-sample.

$ kubectl config current-context
gke_$PROJECT_ID_asia-northeast1-a_micro-sample

Push the images to GCR

We will push the built images to GCR, now the GCP project is created.

docker push gcr.io/$PROJECT_ID/micro-sample-frontend:v0.1
docker push gcr.io/$PROJECT_ID/micro-sample-backend:v0.1

You should be able to see your repositories in your GCR.

Create service yaml files.

Make sure to replace the $PROJECT_ID with your own GCP project id. We will create a new folder named infrastructure and store all the yaml files in it.

infrastructure$ tree
.
├── backend-deployment.yml
├── backend-service.yml
├── frontend-deployment.yml
└── frontend-service.yml

0 directories, 4 files

`infrastructure/backend-deployment.yml`

apiVersion: apps/v1
kind: Deployment
metadata:
  name: micro-sample-backend-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: micro-sample
  template:
    metadata:
      labels:
        app: micro-sample
        tier: backend
        track: stable
    spec:
      containers:
      - name: micro-sample
        image: gcr.io/$PROJECT_ID/micro-sample-backend:v0.1
        ports:
        - containerPort: 8000

`infrastructure/backend-service.yml`

kind: Service
apiVersion: v1
metadata:
  name: micro-sample-service-backend
spec:
  selector:
    app: micro-sample
    tier: backend
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

`infrastructure/frontend-deployment.yml`

apiVersion: apps/v1
kind: Deployment
metadata:
  name: micro-sample-frontend-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: micro-sample
  template:
    metadata:
      labels:
        app: micro-sample
        tier: frontend
        track: stable
    spec:
      containers:
      - name: micro-sample-frontend
        image: gcr.io/$PROJECT_ID/micro-sample-frontend:v0.1
        ports:
          - containerPort: 8080
            name: http
        env:
          - name: BACKEND_SERVICE_NAME
            value: micro-sample-service-backend.default

`infrastructure/frontend-service.yml`

kind: Service
apiVersion: v1
metadata:
  name: micro-sample-service-frontend
spec:
  type: LoadBalancer
  selector:
    app: micro-sample
    tier: frontend
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Configurations in GCP

$ kubectl apply -f frontend-service.yml
service/micro-sample-service-frontend created

$ kubectl apply -f frontend-deployment.yml
deployment.apps/micro-sample-frontend-deployment created

$ kubectl apply -f backend-service.yml
service/micro-sample-service-backend created

$ kubectl apply -f backend-deployment.yml
deployment.apps/micro-sample-backend-deployment created

Check the pods in your cluster

In your local machine when you run kubectl get pods, you should be able to see that all the pods are up and running.

$ kubectl get pods
NAME                                                READY   STATUS    RESTARTS   AGE
micro-sample-backend-deployment-854c888c95-46dp5    1/1     Running   0          98s
micro-sample-backend-deployment-854c888c95-l4g48    1/1     Running   0          98s
micro-sample-frontend-deployment-5cf875f7c9-2htft   1/1     Running   0          3m33s
micro-sample-frontend-deployment-5cf875f7c9-g4kpn   1/1     Running   0          3m33s

Check the external IP of your cluster and run curl. You should be able to get the results from the API.

$ kubectl get svc
NAME                            TYPE           CLUSTER-IP   EXTERNAL-IP    PORT(S)        AGE
kubernetes                      ClusterIP      10.4.0.1     <none>         443/TCP        15m
micro-sample-service-backend    ClusterIP      10.4.8.222   <none>         8000/TCP       51s
micro-sample-service-frontend   LoadBalancer   10.4.15.80   EXTERNAL_IP   80:31017/TCP   7m44s

$ curl "http://EXTERNAL_IP/increment?val=1"
{"val":2}

Cleaning Up

We will delete both the frontend and backend services.

$ kubectl delete svc micro-sample-service-frontend
service "micro-sample-service-frontend" deleted

//check if they are deleted
$ kubectl get services
NAME                           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE
kubernetes                     ClusterIP   10.4.0.1     <none>        443/TCP    14h

Finally we will delete the cluster.

$ gcloud container clusters delete micro-sample
The following clusters will be deleted.
 - [micro-sample] in [asia-northeast1-a]

Do you want to continue (Y/n)?  Y

Deleting cluster micro-sample...done.

We should see in GKE that the cluster has been deleted.

References

Sorry, only Japanese available.

雰囲気でgRPC,GKE+kubernetes使ってマイクロサービス作る

Mini gRPC Project (1): Creating a Simple Increment API on Go

Reishi Mitani — Thu, 15 Oct 2020 09:48:50 +0000

Objectives

To create an api function that increments the given argument.

$ curl "http://localhost:8080/increment?val=3"
{"val":4} //the api returns 4
$ curl "http://localhost:8080/increment?val=10"
{"val":11} //the api returns 11

Prerequisites

MacOS Catalina
Already have gopaths configured

Download necessary packages

$ go get -u github.com/golang/protobuf/protoc-gen-go
$ go get -u github.com/grpc-ecosystem/go-grpc-middleware/logging/zap
$ go get -u go.uber.org/zap

Create folders

micro-prac$ tree
.
├── proto
│   ├── calc.proto
│   └── gen
│       └── calc.pb.go # will be created using command
└── src
    ├── backend
    │   └── main.go
    └── frontend
        └── main.go

5 directories, 4 files

Create proto files

`proto/calc.proto`

// proto/calc.proto

syntax = "proto3";

service Calc {
    rpc Increment(NumRequest) returns (NumResponse) {}
}

message NumRequest {
    int64 val = 1;
}

message NumResponse {
    int64 val = 1;
}

Use the following command in your path (I got some warning but it worked okay).

//create gen folder for string pb.proto files
proto$ mkdir gen

proto$ protoc --go_out=plugins=grpc:gen calc.proto
2020/10/15 18:04:20 WARNING: Missing 'go_package' option in "calc.proto",
  1 package main
please specify it with the full Go package path as
a future release of protoc-gen-go will require this be specified.

You should see a calc.pb.go file created in the gen folder.

proto/gen$ cat calc.pb.go
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
//  protoc-gen-go v1.25.0-devel
//  protoc        v3.13.0
// source: calc.proto

package calc

import (
    context "context"
    proto "github.com/golang/protobuf/proto"
    grpc "google.golang.org/grpc"
    codes "google.golang.org/grpc/codes"
    status "google.golang.org/grpc/status"
    protoreflect "google.golang.org/protobuf/reflect/protoreflect"
    protoimpl "google.golang.org/protobuf/runtime/protoimpl"
    reflect "reflect"
    sync "sync"
)

const (
    // Verify that this generated code is sufficiently up-to-date.
    _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
    // Verify that runtime/protoimpl is sufficiently up-to-date.
    _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.ProtoPackageIsVersion4

type NumRequest struct {
    state         protoimpl.MessageState
    sizeCache     protoimpl.SizeCache
    unknownFields protoimpl.UnknownFields

    Val int64 `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
}

func (x *NumRequest) Reset() {
    *x = NumRequest{}
    if protoimpl.UnsafeEnabled {
        mi := &file_calc_proto_msgTypes[0]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
    }
}

func (x *NumRequest) String() string {
    return protoimpl.X.MessageStringOf(x)
}

func (*NumRequest) ProtoMessage() {}

func (x *NumRequest) ProtoReflect() protoreflect.Message {
    mi := &file_calc_proto_msgTypes[0]
    if protoimpl.UnsafeEnabled && x != nil {
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        if ms.LoadMessageInfo() == nil {
            ms.StoreMessageInfo(mi)
        }
        return ms
    }
    return mi.MessageOf(x)
}

// Deprecated: Use NumRequest.ProtoReflect.Descriptor instead.
func (*NumRequest) Descriptor() ([]byte, []int) {
    return file_calc_proto_rawDescGZIP(), []int{0}
}

func (x *NumRequest) GetVal() int64 {
    if x != nil {
        return x.Val
    }
    return 0
}

type NumResponse struct {
    state         protoimpl.MessageState
    sizeCache     protoimpl.SizeCache
    unknownFields protoimpl.UnknownFields

    Val int64 `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
}

func (x *NumResponse) Reset() {
    *x = NumResponse{}
    if protoimpl.UnsafeEnabled {
        mi := &file_calc_proto_msgTypes[1]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
    }
}

func (x *NumResponse) String() string {
    return protoimpl.X.MessageStringOf(x)
}

func (*NumResponse) ProtoMessage() {}

func (x *NumResponse) ProtoReflect() protoreflect.Message {
    mi := &file_calc_proto_msgTypes[1]
    if protoimpl.UnsafeEnabled && x != nil {
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        if ms.LoadMessageInfo() == nil {
            ms.StoreMessageInfo(mi)
        }
        return ms
    }
    return mi.MessageOf(x)
}

// Deprecated: Use NumResponse.ProtoReflect.Descriptor instead.
func (*NumResponse) Descriptor() ([]byte, []int) {
    return file_calc_proto_rawDescGZIP(), []int{1}
}

func (x *NumResponse) GetVal() int64 {
    if x != nil {
        return x.Val
    }
    return 0
}

var File_calc_proto protoreflect.FileDescriptor

var file_calc_proto_rawDesc = []byte{
    0x0a, 0x0a, 0x63, 0x61, 0x6c, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x1e, 0x0a, 0x0a,
    0x4e, 0x75, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61,
    0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x76, 0x61, 0x6c, 0x22, 0x1f, 0x0a, 0x0b,
    0x4e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x76,
    0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x76, 0x61, 0x6c, 0x32, 0x30, 0x0a,
    0x04, 0x43, 0x61, 0x6c, 0x63, 0x12, 0x28, 0x0a, 0x09, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65,
    0x6e, 0x74, 0x12, 0x0b, 0x2e, 0x4e, 0x75, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
    0x0c, 0x2e, 0x4e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x62,
    0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
    file_calc_proto_rawDescOnce sync.Once
    file_calc_proto_rawDescData = file_calc_proto_rawDesc
)

func file_calc_proto_rawDescGZIP() []byte {
    file_calc_proto_rawDescOnce.Do(func() {
        file_calc_proto_rawDescData = protoimpl.X.CompressGZIP(file_calc_proto_rawDescData)
    })
    return file_calc_proto_rawDescData
}

var file_calc_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_calc_proto_goTypes = []interface{}{
    (*NumRequest)(nil),  // 0: NumRequest
    (*NumResponse)(nil), // 1: NumResponse
}
var file_calc_proto_depIdxs = []int32{
    0, // 0: Calc.Increment:input_type -> NumRequest
    1, // 1: Calc.Increment:output_type -> NumResponse
    1, // [1:2] is the sub-list for method output_type
    0, // [0:1] is the sub-list for method input_type
    0, // [0:0] is the sub-list for extension type_name
    0, // [0:0] is the sub-list for extension extendee
    0, // [0:0] is the sub-list for field type_name
}

func init() { file_calc_proto_init() }
func file_calc_proto_init() {
    if File_calc_proto != nil {
        return
    }
    if !protoimpl.UnsafeEnabled {
        file_calc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
            switch v := v.(*NumRequest); i {
            case 0:
                return &v.state
            case 1:
                return &v.sizeCache
            case 2:
                return &v.unknownFields
            default:
                return nil
            }
        }
        file_calc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
            switch v := v.(*NumResponse); i {
            case 0:
                return &v.state
            case 1:
                return &v.sizeCache
            case 2:
                return &v.unknownFields
            default:
                return nil
            }
        }
    }
    type x struct{}
    out := protoimpl.TypeBuilder{
        File: protoimpl.DescBuilder{
            GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
            RawDescriptor: file_calc_proto_rawDesc,
            NumEnums:      0,
            NumMessages:   2,
            NumExtensions: 0,
            NumServices:   1,
        },
        GoTypes:           file_calc_proto_goTypes,
        DependencyIndexes: file_calc_proto_depIdxs,
        MessageInfos:      file_calc_proto_msgTypes,
    }.Build()
    File_calc_proto = out.File
    file_calc_proto_rawDesc = nil
    file_calc_proto_goTypes = nil
    file_calc_proto_depIdxs = nil
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// CalcClient is the client API for Calc service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CalcClient interface {
    Increment(ctx context.Context, in *NumRequest, opts ...grpc.CallOption) (*NumResponse, error)
}

type calcClient struct {
    cc grpc.ClientConnInterface
}

func NewCalcClient(cc grpc.ClientConnInterface) CalcClient {
    return &calcClient{cc}
}

func (c *calcClient) Increment(ctx context.Context, in *NumRequest, opts ...grpc.CallOption) (*NumResponse, error) {
    out := new(NumResponse)
    err := c.cc.Invoke(ctx, "/Calc/Increment", in, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

// CalcServer is the server API for Calc service.
type CalcServer interface {
    Increment(context.Context, *NumRequest) (*NumResponse, error)
}

// UnimplementedCalcServer can be embedded to have forward compatible implementations.
type UnimplementedCalcServer struct {
}

func (*UnimplementedCalcServer) Increment(context.Context, *NumRequest) (*NumResponse, error) {
    return nil, status.Errorf(codes.Unimplemented, "method Increment not implemented")
}

func RegisterCalcServer(s *grpc.Server, srv CalcServer) {
    s.RegisterService(&_Calc_serviceDesc, srv)
}

func _Calc_Increment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
    in := new(NumRequest)
    if err := dec(in); err != nil {
        return nil, err
    }
    if interceptor == nil {
        return srv.(CalcServer).Increment(ctx, in)
    }
    info := &grpc.UnaryServerInfo{
        Server:     srv,
        FullMethod: "/Calc/Increment",
    }
    handler := func(ctx context.Context, req interface{}) (interface{}, error) {
        return srv.(CalcServer).Increment(ctx, req.(*NumRequest))
  1 // this file is sample for client
    }
    return interceptor(ctx, in, info, handler)
}

var _Calc_serviceDesc = grpc.ServiceDesc{
    ServiceName: "Calc",
    HandlerType: (*CalcServer)(nil),
    Methods: []grpc.MethodDesc{
        {
            MethodName: "Increment",
            Handler:    _Calc_Increment_Handler,
        },
    },
    Streams:  []grpc.StreamDesc{},
  1 // this file is sample for client
    Metadata: "calc.proto",
}

Create frontend files

`src/frontend/main.go`

# src/frontend/main.go
// this file is sample for client
package main

import (
    "context"
    "encoding/json"
    "log"
    "net/http"
    "os"
    "strconv"

    "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
    "go.uber.org/zap"
    "google.golang.org/grpc"

    pb "../../proto/gen"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Println("health check")
    })
    http.HandleFunc("/increment", incrementHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
    log.Println("listen started")
}

func incrementHandler(w http.ResponseWriter, r *http.Request) {
    logger, err := zap.NewDevelopment()
    if err != nil {
        log.Fatalf("failed to create logger :%v", err)
    }
    var servName string
    if s := os.Getenv("BACKEND_SERVICE_NAME"); s != "" {
        servName = s
    } else {
        servName = "127.0.0.1"
    }
    logger.Debug("go", zap.String("servName", servName))
    conn, err := grpc.Dial(servName+":8000", grpc.WithInsecure(), grpc.WithUnaryInterceptor(
        grpc_zap.UnaryClientInterceptor(logger),
    ))
    grpc_zap.ReplaceGrpcLogger(logger)
    if err != nil {
        log.Fatalf("failed to connect :%v", err)
    }
    defer conn.Close()

    val, err := strconv.Atoi(r.URL.Query().Get("val"))
    if err != nil {
        logger.Error("got value error", zap.Error(err))
    }
    client := pb.NewCalcClient(conn)
    ctx := context.Background()
    res, err := client.Increment(ctx, &pb.NumRequest{Val: int64(val)})
    if err != nil {
        logger.Error("got error from server", zap.Error(err))
    }
    logger.Info("got response", zap.Int64("value", res.Val))
    b, err := json.Marshal(res)
    if err != nil {
        logger.Error("json parse error", zap.Error(err))
    }
    w.Write(b)
}

Create backend files

`src/backend/main.go`

package main

import (
    "fmt"
    "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
    "go.uber.org/zap"
    "google.golang.org/grpc"
    "log"
    "net"
    pb "../../proto/gen"
    context "golang.org/x/net/context"
)

func main() {
    port := 8000
    logger, err := zap.NewDevelopment()
    if err != nil {
        log.Fatalf("failed to create logger :%v", err)
    }
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
    if err != nil {
        logger.Fatal("failed to listen", zap.Error(err))
    }
    server := grpc.NewServer(grpc.UnaryInterceptor(
        grpc_zap.UnaryServerInterceptor(logger),
    ))
    grpc_zap.ReplaceGrpcLogger(logger)
    pb.RegisterCalcServer(server, &CalcService{})
    server.Serve(lis)
}

type CalcService struct{}

func (s *CalcService) Increment(ctx context.Context, req *pb.NumRequest) (*pb.NumResponse, error) {
    req.Val++
    return &pb.NumResponse{Val: req.Val}, nil
}

Run the go run main.go in both backend and frontend.

When you use curl, you should be able to get a response.

Run the curl commands

$ curl "http://localhost:8080/increment?val=10"
{"val":11}

Results on frontend side

frontend$ go run main.go
2020-10-15T18:21:11.609+0900    DEBUG   frontend/main.go:39 go  {"servName": "127.0.0.1"}
2020-10-15T18:21:11.610+0900    INFO    zap/grpclogger.go:46    [core]Subchannel picks a new address "127.0.0.1:8000" to connect    {"system": "grpc", "grpc_log": true}
2020-10-15T18:21:11.610+0900    INFO    zap/grpclogger.go:46    [core]Channel Connectivity change to CONNECTING {"system": "grpc", "grpc_log": true}
2020-10-15T18:21:11.612+0900    INFO    zap/grpclogger.go:46    [core]Subchannel Connectivity change to READY   {"system": "grpc", "grpc_log": true}
2020-10-15T18:21:11.613+0900    INFO    zap/grpclogger.go:46    [core]pickfirstBalancer: UpdateSubConnState: 0xc0001ac6e0, {READY <nil>}    {"system": "grpc", "grpc_log": true}
2020-10-15T18:21:11.613+0900    INFO    zap/grpclogger.go:46    [core]Channel Connectivity change to READY  {"system": "grpc", "grpc_log": true}
2020-10-15T18:21:11.616+0900    DEBUG   zap/options.go:203  finished client unary call  {"system": "grpc", "span.kind": "client", "grpc.service": "Calc", "grpc.method": "Increment", "grpc.code": "OK", "grpc.time_ms": 6.538000106811523}

Results on backend

$ go run main.go
2020-10-15T18:21:11.615+0900    INFO    zap/options.go:203  finished unary call with code OK    {"grpc.start_time": "2020-10-15T18:21:11+09:00", "system": "grpc", "span.kind": "server", "grpc.service": "Calc", "grpc.method": "Increment", "grpc.code": "OK", "grpc.time_ms": 0.21799999475479126}
2020-10-15T18:21:11.617+0900    INFO    zap/grpclogger.go:46    [transport]transport: loopyWriter.run returning. connection error: desc = "transport is closing"    {"system": "grpc", "grpc_log": true}
2020-10-15T18:21:15.505+0900    INFO    zap/options.go:203  finished unary call with code OK    {"grpc.start_time": "2020-10-15T18:21:15+09:00", "system": "grpc", "span.kind": "server", "grpc.service": "Calc", "grpc.method": "Increment", "grpc.code": "OK", "grpc.time_ms": 0.023000000044703484}
2020-10-15T18:21:15.506+0900    INFO    zap/grpclogger.go:46    [transport]transport: loopyWriter.run returning. connection error: desc = "transport is closing"    {"system": "grpc", "grpc_log": true}

Next: Deployment on GKE

We will deploy this simple gRPC API on GKE here: Mini gRPC Project (2): Deploying the gRPC API on k8s

Using Let's Encrypt on AWS EC2 Instance

Reishi Mitani — Mon, 05 Oct 2020 04:13:30 +0000

Objectives

Create a SSL certificate on your EC2 instance.
We will not consider using php, maria-db on this EC instance (unlike in the documentation).

Documentations

Tutorial: Configure SSL/TLS on Amazon Linux 2

However, some of the instructions here in the documentation were outdated.

Prerequisites

Already launched an EC2 instance (in case of this situation, Amazon Linux 2)
The EC2 security groups have ports 80, 443, and 22 open (http, https, and ssh respectively).
Already have a domain created on Route 53 or somewhere else.

Procedures

Install apache on your EC2 machine

Tutorial: Install a LAMP web server on Amazon Linux 2

$ sudo yum update -y
$ sudo yum install -y httpd
$ sudo systemctl start httpd
$ sudo systemctl enable httpd
$ sudo systemctl is-enabled httpd

Create a localhost.crt

$ sudo yum install -y mod_ssl
$ cd /etc/pki/tls/certs
$ sudo ./make-dummy-cert localhost.crt

Do not comment out the SSLCertificateKeyFile /etc/pki/tls/private/localhost.key, although it says so in the documentation. Otherwise, you will get an error when running apache (reason unknown).

I actually do not know whether this localhost.crt is even necessary.

Install and run certbot

$ sudo wget -r --no-parent -A 'epel-release-*.rpm' http://dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/
$ sudo rpm -Uvh dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/epel-release-*.rpm
$ sudo yum-config-manager --enable epel*

Add the following lines in your /etc/httpd/conf/httpd.conf and after Listen 80, insert the following.

<VirtualHost *:80>
    DocumentRoot "/var/www/html"
    ServerName "example.com"
    ServerAlias "www.example.com"
</VirtualHost>

Restart apache, install certbot, and run it.

$ sudo systemctl restart httpd
$ sudo yum install -y certbot python2-certbot-apache
$ sudo certbot

Agree to the terms.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please read the Terms of Service at
https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf. You must
agree in order to register with the ACME server at
https://acme-v02.api.letsencrypt.org/directory
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(A)gree/(C)ancel: A

Choose the domain names you want to activate.

Which names would you like to activate HTTPS for?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: example.com
2: www.example.com
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate numbers separated by commas and/or spaces, or leave input
blank to select all options shown (Enter 'c' to cancel):

After this, answer to a couple of questions, and you should be done!

Congratulations! You have successfully enabled https://example.com and
https://www.example.com

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=example.com
https://www.ssllabs.com/ssltest/analyze.html?d=www.example.com
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/certbot.oneeyedman.net/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/certbot.oneeyedman.net/privkey.pem
   Your cert will expire on 2019-08-01. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.

You can see your certificates, private key, and chain at /etc/letsencrypt/live/certbot.oneeyedman.net. You can import these into your Amazon Certificate Manager, and use it for your Elastic Load Balancers.

P.S.

There are other ways to install certbot apart from sudo yum install, such as curl. I followed the AWS docs on this one.
But in case of using curl, you will have to configure the settings so that it matches the requirements of Amazon Linux 2.

Tutorial with Docker Swarm and Stack

Reishi Mitani — Thu, 01 Oct 2020 12:21:58 +0000

Objectives

We will

Create a docker image and push it to docker hub
Pull the image from the hub and create a stack.

Procedures

First I created a directory as below.

$ mkdir docker-stack-tutorial

We will create the Dockerfile, and some python scripts.
The directory should look like below.

$ tree
.
├── Dockerfile
├── app.py
└── requirements.txt

0 directories, 3 files

The dockerfile is as below.

# Dockerfile

FROM python:3.7

WORKDIR /app

ADD . /app

RUN pip install -r requirements.txt

EXPOSE 80

ENV NAME World

CMD ["python", "app.py"]

app.py for python is written as below.

# app.py


from flask import Flask
from redis import Redis, RedisError
import os
import socket

# Connect to Redis
redis = Redis(host="redis", db=0, socket_connect_timeout=2, socket_timeout=2)

app = Flask(__name__)

@app.route("/")
def hello():
    try:
        visits = redis.incr('counter')
    except RedisError:
        visits = "<i>cannot connect to Redis, counter disabled</i>"

    html = "<h3>Hello {name}!</h3>" \
           "<b>Hostname:</b> {hostname}<br/>" \
           "<b>Visits:</b> {visits}"
    return html.format(name=os.getenv('NAME', "world"), hostname=socket.gethostname(), visits=visits)

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)

Finally, the requirements.txt is:

# requirements.txt
Flask
Redis

Now we will build and run the docker image.

$ docker build -t python-server .
Sending build context to Docker daemon   5.12kB
Step 1/7 : FROM python:3.7
 ---> 5c1cd4638fb7
............

$ docker run -p 4000:80 python-server
 * Serving Flask app "app" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://0.0.0.0:80/ (Press CTRL+C to quit)

Go to localhost:4000 and you should see this page (For some reason, redis was not working.):

We see that the container id is 99f360ce0c36 here. We will commit the image, and push it to docker hub.

$ docker login
Authenticating with existing credentials...
Login Succeeded

$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS              PORTS                  NAMES
99f360ce0c36        python-server       "python app.py"     About a minute ago   Up About a minute   0.0.0.0:4000->80/tcp   keen_galois

$ docker commit 99f360ce0c36 python-server:latest
sha256:9dbcf7df033bb595c6e4c6528dd125716f11355d43dcea4dc8ccbaaced38c44c

$ docker tag python-server:latest USERNAME/python-server:latest

$ docker push USERNAME/python-server:latest

Now we will create our docker-compose.yml file.

version: "3"
services:
  web:
    image: USERNAME/python-server:latest
    deploy:
      replicas: 5
      resources:
        limits:
          cpus: "0.1"
          memory: 50M
      restart_policy:
        condition: on-failure
    ports:
      - "80:80"
    networks:
      - webnet
networks:
  webnet:

We will initialize the swarm and deploy it.

$ docker swarm init
Swarm initialized: current node (nrgwdwv97ioguu0gqq7t19kln) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-3lcxtiaau24gw21h2bgkd1ptavl56yczedbcm7d4e865naj8ks-7c5sgf7jh4youa7xsq2l3dt3j 192.168.65.3:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

$ docker stack deploy -c docker-compose.yml getstartedexample
Creating network getstartedexample_webnet
Creating service getstartedexample_web

We can see all the nodes here using ps.

$ docker stack ps getstartedexample
ID                  NAME                      IMAGE                                  NODE                DESIRED STATE       CURRENT STATE            ERROR               PORTS
x3xradislkhr        getstartedexample_web.1   USERNAME/python-server:latest   docker-desktop      Running             Running 12 seconds ago
shlygtlq66e0        getstartedexample_web.2   USERNAME/python-server:latest   docker-desktop      Running             Running 12 seconds ago
uk1wexhimc8a        getstartedexample_web.3   USERNAME/python-server:latest   docker-desktop      Running             Running 12 seconds ago
rijovk7yzr48        getstartedexample_web.4   USERNAME/python-server:latest   docker-desktop      Running             Running 12 seconds ago
avlqa3hxgbt2        getstartedexample_web.5   USERNAME/python-server:latest   docker-desktop      Running             Running 12 seconds ago

When you access localhost, you should see the node ids every time you refresh.

Use the command below to exit.

$ docker stack rm getstartedexample
Removing service getstartedexample_web
Removing network getstartedexample_webnet

Installing ECS-CLI in your Mac

Reishi Mitani — Sat, 26 Sep 2020 15:58:42 +0000

Prerequisites

MacOS Catalina
More information can be found here in the documentation: Installing the Amazon ECS CLI

Procedures

Download ecs-cli using sudo curl.

$ sudo curl -Lo /usr/local/bin/ecs-cli https://amazon-ecs-cli.s3.amazonaws.com/ecs-cli-darwin-amd64-latest
Password:
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 49.5M  100 49.5M    0     0  3419k      0  0:00:14  0:00:14 --:--:-- 4012k

Install gnupg, or GNU privacy guard. This may take a few minutes.

$ brew install gnupg

Run the following command. This will retrieve the key.

$ gpg --keyserver hkp://keys.gnupg.net --recv BCE9D9A42D51784F
gpg: directory '/Users/USERNAME/.gnupg' created
gpg: keybox '/Users/USERNAME/.gnupg/pubring.kbx' created
gpg: /Users/USERNAME/.gnupg/trustdb.gpg: trustdb created
gpg: key BCE9D9A42D51784F: public key "Amazon ECS <ecs-security@amazon.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1

Download the ECS CLI signatures.

$ curl -Lo ecs-cli.asc https://amazon-ecs-cli.s3.amazonaws.com/ecs-cli-darwin-amd64-latest.asc
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   821  100   821    0     0   1080      0 --:--:-- --:--:-- --:--:--  1078

Verigy the key.

$ gpg --verify ecs-cli.asc /usr/local/bin/ecs-cli
gpg: Signature made 水  7/ 8 07:29:27 2020 JST
gpg:                using RSA key DE3CBD61ADAF8B8E
gpg: Good signature from "Amazon ECS <ecs-security@amazon.com>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: F34C 3DDA E729 26B0 79BE  AEC6 BCE9 D9A4 2D51 784F
     Subkey fingerprint: EB3D F841 E2C9 212A 2BD4  2232 DE3C BD61 ADAF 8B8E

Add the necessary restrictions.

$ sudo chmod +x /usr/local/bin/ecs-cli

If you are able to check the version, it is successful.

$ ecs-cli --version
ecs-cli version 1.20.0 (7547c45)

Creating an App on Elastic Beanstalk from Terminal

Reishi Mitani — Thu, 24 Sep 2020 09:28:29 +0000

Prerequisites

MacOS Catalina
Have the ebcli installed

Initialize the elastic beanstalk application

We will choose docker for the platform.

$ eb init

Select a default region
1) us-east-1 : US East (N. Virginia)
2) us-west-1 : US West (N. California)
3) us-west-2 : US West (Oregon)
4) eu-west-1 : EU (Ireland)
5) eu-central-1 : EU (Frankfurt)
6) ap-south-1 : Asia Pacific (Mumbai)
7) ap-southeast-1 : Asia Pacific (Singapore)
8) ap-southeast-2 : Asia Pacific (Sydney)
9) ap-northeast-1 : Asia Pacific (Tokyo)
10) ap-northeast-2 : Asia Pacific (Seoul)
11) sa-east-1 : South America (Sao Paulo)
12) cn-north-1 : China (Beijing)
13) cn-northwest-1 : China (Ningxia)
14) us-east-2 : US East (Ohio)
15) ca-central-1 : Canada (Central)
16) eu-west-2 : EU (London)
17) eu-west-3 : EU (Paris)
18) eu-north-1 : EU (Stockholm)
19) eu-south-1 : EU (Milano)
20) ap-east-1 : Asia Pacific (Hong Kong)
21) me-south-1 : Middle East (Bahrain)
22) af-south-1 : Africa (Cape Town)
(default is 3): 1


Select an application to use
1) eb-https
2) Up
3) [ Create new Application ]
(default is 3):


Enter Application Name
(default is "eb-https2"):
Application eb-https2 has been created.
Select a platform.
1) .NET Core on Linux
2) .NET on Windows Server
3) Docker
4) GlassFish
5) Go
6) Java
7) Node.js
8) PHP
9) Packer
10) Python
11) Ruby
12) Tomcat
(make a selection): 3

Select a platform branch.
1) Docker running on 64bit Amazon Linux 2
2) Multi-container Docker running on 64bit Amazon Linux
3) Docker running on 64bit Amazon Linux
(default is 1): 1

Cannot setup CodeCommit because there is no Source Control setup, continuing with initialization
Do you want to set up SSH for your instances?
(Y/n): n

Create the environment

We will add the --vpc option to create the virtual private cloud.

$ eb create --vpc
// press enter
Enter Environment Name
(default is eb-https2-dev):
//press enter
Enter DNS CNAME prefix
(default is eb-https2-dev):

Select a load balancer type
press enter
1) classic
2) application
3) network
(default is 2):

Would you like to enable Spot Fleet requests for this environment?
(y/N): N

Enter the VPC ID: vpc-e3e2079e
Do you want to associate a public IP address? (Y/n): Y

// I entered the same subnets for both the EC2 and ELB subnets.
Enter a comma-separated list of Amazon EC2 subnets: subnet-416eba60, subnet-764a8029
Enter a comma-separated list of Amazon ELB subnets: subnet-416eba60, subnet-764a8029
Do you want the load balancer to be public? (Select no for internal) (Y/n): Y
Enter a comma-separated list of Amazon VPC security groups: sg-01475203460d2c24b
NOTE: The current directory does not contain any source code. Elastic Beanstalk is launching the sample application instead.
Do you want to download the sample application into the current directory?
(Y/n): Y

After about 10 minutes, if you are successful, you should see the environment built in your console.
When you access the url, you should see the sample page here.

If you chose Y and downloaded the sample application into the current directory, your folder should look like this.

$ tree
.
├── Dockerfile
├── Dockerrun.aws.json
├── application.py
└── cron.yaml

0 directories, 4 files

Deploying a Sample React App to ECS

Reishi Mitani — Sun, 20 Sep 2020 07:33:02 +0000

Objective

To create & deploy a sample react application.

Prerequisites

MacOS Catalina
Have the necessary modules for react installed
Have docker installed
Have awscli installed

Creating the react app

Create a react app in terminal.

$ create-react-app sample-react-ecs-app
// if not working, try $ npx create-react-app sample-react-ecs-app
$ cd sample-react-ecs-app/
$ touch Dockerfile
$ tree -I node_modules
.
├── Dockerfile
├── README.md
├── package.json
├── public
│   ├── favicon.ico
│   ├── index.html
│   └── manifest.json
├── src
│   ├── App.css
│   ├── App.js
│   ├── App.test.js
│   ├── index.css
│   ├── index.js
│   ├── logo.svg
│   └── serviceWorker.js
└── yarn.lock

The contents of Dockerfile is as below:

// Dockerfile
FROM node:11-alpine as builder
WORKDIR /app
COPY package.json .
COPY yarn.lock .
RUN yarn install
COPY . .
RUN yarn build

FROM nginx:1.15-alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80

Build the image.

$ docker image build -t sample-react-ecs-app:latest .
Sending build context to Docker daemon  181.6MB
Step 1/10 : FROM node:11-alpine as builder
...
...
...
Successfully built 9a110f83b860
Successfully tagged sample-react-ecs-app:latest

Check the image.

$ docker images | grep sample-react-ecs-app
sample-react-ecs-app                  latest              9a110f83b860        5 minutes ago       16.6MB

Run the server, and in localhost:80, you should be able to access the following page.

$ docker container run --rm -p 80:80 sample-react-ecs-app:latest
172.17.0.1 - - [20/Sep/2020:06:23:55 +0000] "GET / HTTP/1.1" 200 2247 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36" "-"

Configurations in ECS

Open the ECS in your AWS console.

Create a new repository.

We will name the repository sample-react-ecs-app.

Open the repository page and click view push commands.

$ aws ecr get-login-password --region ap-northeast-1 | docker login --username AWS --password-stdin xxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com
Login Succeeded
$ docker tag sample-react-ecs-app:latest xxxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com/sample-react-ecs-app:latest
$ docker push xxxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com/sample-react-ecs-app:latest
The push refers to repository [xxxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com/sample-react-ecs-app]
83f5a6793760: Pushed
a521e1bbddf5: Pushed
bf381a670956: Pushed
a61993362baf: Pushed
f1b5933fe4b5: Pushed
latest: digest: sha256:eca276a688f71fbf03d0044354ab5d693cd9090d2497b9e0c3d37ef2bd25ca2b size: 1363

You should see your own container in the ECS repository.

Next, we will create the cluster.

We will select the EC2 Linux + Network version.

We will name the cluster sample-react-ecs-app-cluster.

We can see the cluster newly created in the AWS console.

The situation of the clusters can be found in the cluster page.

Now we will click on the task definitions.

We will add the task as below, called sample-react-ecs-app-task.

Now we will run the tasks on our cluster.

Now the tasks are running on the cluster.

And our sample website is running on the port 32768.

I skipped on some parts, and I hope to update this article as much as possible.

References

Sorry, only Japanese available.

AWS ECRとECSの入門(EC2編) ~ ECSのEC2版を使ってReactのDockerアプリケーションをAWS上で稼働させる方法 ~