Skip to content

2016

  • in podcast
  • 2 min read

What is Blockchain and How is It Used?

Hello and welcome to Continuous Improvement, the podcast where we explore the latest advancements and innovations shaping our world. I'm your host, Victor, and in today's episode, we will delve into the exciting topic of blockchain technology.

Many of my friends have been asking me about the emergence of the blockchain revolution, and I must say, the possibilities are truly remarkable. According to recent news, four of the world's largest banks have teamed up to develop a new form of digital cash. This digital cash aims to become an industry standard for clearing and settling financial trades over blockchain technology. Meanwhile, Ripple has raised $55 million in Series B funding, highlighting the growing interest and investment in this field.

So, let's start by understanding what exactly blockchain is. Simply put, it is a data structure that serves as a digital ledger for transactions. What sets it apart is that this ledger is shared among a distributed network of computers, numbering in the millions. Utilizing state-of-the-art cryptography, the technology securely manages the ledger.

Blockchain operates on a consensus model where every node agrees to every transaction, eliminating the need for a central counterparty in traditional settlement processes. This offers broad implications for cross-currency payments by making them more efficient, eliminating time delays, and reducing back-office costs.

But how is blockchain used in practice? Well, it allows for direct bank-to-bank settlements, enabling faster and lower-cost global payments. Some applications of this technology include remittance services for retail customers, international transactions, corporate payments, and cross-border intra-bank currency transfers.

The innovation lies in the fact that transactions can occur without needing to know who the other party is. This feature, coupled with the idea of a distributed database, where trust is established through mass collaboration rather than a centralized institution, sets the stage for many exciting possibilities.

So, what problems could be solved with blockchain? Well, it goes beyond the financial market. This technology could provide an immutable record that can be trusted for various uses. In a blockchain, once a block of data is recorded, it becomes very difficult to alter. This can be used for genuine privacy protection. Blockchain could also serve as the basis for an open protocol for web-based identity verification, creating a 'web-of-trust' and storing data in an encrypted format.

The potential of blockchain is enormous, and its ability to disrupt traditional banking is evident. With its decentralized nature and secure transactions, it has the power to reshape the way we handle cross-border payments and even how we establish trust in various aspects of our lives.

Well, that's all we have time for today on Continuous Improvement. I hope you found this episode informative and thought-provoking. Stay tuned for more exciting discussions on the advancements and innovations shaping our world.

  • in zh
  • 1 min read

什麼是區塊鏈，以及它如何被使用？

很多朋友都在問我關於區塊鏈革命的出現。根據最近的新聞，世界四大銀行已經聯手開發一種新形式的數位現金。這種數位現金旨在成為清算和結算金融交易的區塊鏈技術的行業標準。同時，Ripple已經在B輪融資中籌得5500萬美元。在我看來，無疑區塊鏈有潛力顛覆傳統銀行。

何謂區塊鏈？

區塊鏈是一種數據結構，用作交易的數字記錄簿。這個記錄簿在數以百萬計的分散式網絡的電腦之間共享。利用最先進的密碼學，該技術安全地管理記錄簿。區塊鏈依賴共識模型運作：每個節點都同意每一筆交易，從而消除了傳統結算過程中需要中央交易對手(CCP)的需要。

如何使用？

區塊鏈通過使其更高效，對跨貨幣支付有廣泛的影響。它消除了時間延遲並降低了後勤成本。為了回應客戶對更快、更低成本的全球支付的日益增長的需求，區塊鏈允許直接的銀行對銀行的結算。這種技術的一些應用包括零售客戶的匯款服務，國際交易，企業支付和跨國銀行間的貨幣轉帳。

何種創新？

這項技術提供了交易可以在不需要知道對方是誰的情況下進行的機會。其最創新的特點是分散化數據庫的理念，其中信任是通過大規模協作建立的，而不是通過一個負責認證和結算的中心化機構建立的。

可解決哪些問題？

區塊鏈的潛在應用擴展到了金融市場之外。這種技術可能提供一個對於多種用途可以信賴的不可變更的記錄。當前的身份識別基礎設施很容易被破壞；然而，在區塊鏈中，一旦數據塊被記錄，修改起來就變得非常困難。因此，它可以用於真正的隱私保護。每當有人試圖向區塊鏈添加數據時，所有現有的副本都運行算法來驗證交易。試圖欺詐系統的惡意嘗試被拒絕，而預期的交易在大多數節點通過鏈交易歷史驗證其有效性時獲得批准。因此，區塊鏈可以作為基於web的身份驗證的開放協議的基礎，創建一個'信任網絡'，並以加密格式儲存數據。

參考文獻
  1. Martin Arnold, "Big banks plan to coin new digital currency," Financial Times, August 24, 2016, Financial Times Article
  2. Alyssa Jarrett, "Ripple Raises $55 Million in Series B Funding," Ripple official website, September 15, 2016, Ripple Article
  3. Don Tapscott, Alex, and Rik Kirkland, "How Blockchains Could Change the World," McKinsey & Co, May 8, 2016, ValueWalk Article
  • 1 min read

Installing Jupyter Notebook on macOS

I'm using the Anaconda distribution to install Jupyter Notebook.

Step 1: Download Anaconda

First, visit the Anaconda website to download the installer: https://www.anaconda.com/products/distribution

Step 2: Install Anaconda

Run the downloaded installer and follow the graphical prompts to install Anaconda.

Step 3: Attempt to Run Jupyter Notebook

After installation, try running Jupyter Notebook by executing:

jupyter notebook

You may encounter the following error:

> zsh: command not found: jupyter

This happens because the conda command is also not found:

> zsh: command not found: conda

Step 4: Update Shell Configuration

To resolve this issue, open your .zshrc file with your preferred text editor:

vim ~/.zshrc

Add the following line at the bottom of the file:

export PATH="$HOME/anaconda3/bin:$PATH"

Step 5: Restart Shell and Run Jupyter Notebook

Save the file and restart your shell. Try running Jupyter Notebook again. It should now be accessible at http://localhost:8888/.

  • in podcast
  • 2 min read

Installing Jupyter Notebook on macOS

Hello and welcome back to "Continuous Improvement," the podcast where we explore practical tips and techniques for personal and professional growth. I'm your host, Victor, and in today's episode, we'll be discussing the process of installing Jupyter Notebook using the Anaconda distribution.

If you're an aspiring data scientist or simply someone interested in coding and data analysis, Jupyter Notebook is an incredibly useful tool. It allows you to create and share documents that contain live code, equations, visualizations, and narrative text.

So, let's dive right in!

The first step in installing Jupyter Notebook is to download the Anaconda distribution. Head over to https://www.anaconda.com/products/distribution and click on the download link. This will take you to the Anaconda website, where you can find the installer for your operating system.

Once you have downloaded the Anaconda installer, it's time to install it on your machine. Run the installer and follow the graphical prompts that appear on your screen. The installation process is pretty straightforward, but if you encounter any issues, make sure to check the Anaconda documentation for troubleshooting tips.

Once the installation is complete, you might want to test if Jupyter Notebook is working properly. Open your terminal or command prompt and type the following command:

jupyter notebook

However, you might encounter an error at this point. Don't worry, it's a common issue. The error message could be something like:

> zsh: command not found: jupyter

The reason you're seeing this error is because the conda command is also not found. But fret not, there's a simple solution to get things running smoothly.

Open your .zshrc file with your preferred text editor. You can do this by typing:

vim ~/.zshrc

In the .zshrc file, add the following line at the bottom:

export PATH="$HOME/anaconda3/bin:$PATH"

Save the file and close the text editor. Now, it's time to restart your shell. Close and reopen your terminal or command prompt, and now you can try running Jupyter Notebook once again.

Great! Now Jupyter Notebook should be accessible at http://localhost:8888/. You can start creating your notebooks and explore the world of data analysis, visualization, and coding.

That's all for today's episode of "Continuous Improvement." I hope you found this tutorial on installing Jupyter Notebook using the Anaconda distribution helpful. Remember, continuous improvement is key to personal and professional growth, so keep exploring, learning, and enhancing your skills.

If you have any questions or suggestions for future episodes, feel free to reach out to us. You can find us on Twitter, Instagram, or Facebook at @continuousimprovementpodcast.

Take care, and until next time!

  • in zh
  • 1 min read

在 macOS 上安裝 Jupyter Notebook

我正在使用 Anaconda 發行版安裝 Jupyter Notebook。

步驟 1：下載 Anaconda

首先，訪問 Anaconda 網站以下載安裝程式：https://www.anaconda.com/products/distribution

步驟 2：安裝 Anaconda

運行下載的安裝程式並按照圖形提示進行 Anaconda 的安裝。

步驟 3：嘗試運行 Jupyter Notebook

安裝完成後，嘗試執行 Jupyter Notebook：

jupyter notebook

你可能會遇到以下錯誤：

> zsh: command not found: jupyter

這是因為 conda 命令也找不到：

> zsh: command not found: conda

步驟 4：更新 Shell 配置

為了解決此問題，使用你偏好的文本編輯器打開你的 .zshrc 文件：

vim ~/.zshrc

在文件底部添加以下行：

export PATH="$HOME/anaconda3/bin:$PATH"

步驟 5：重新啓動 Shell 並運行 Jupyter Notebook

保存文件並重新啓動你的 shell。嘗試再次運行 Jupyter Notebook。現在應該可以在 http://localhost:8888/ 上訪問。

  • 3 min read

Launching RancherOS on AWS EC2

RancherOS is a Linux distribution designed for running Docker containers. While there is an AMI (Amazon Machine Image) available in the AWS Marketplace, setting up the security group and other configurations can be tricky. This guide serves as the missing manual.

1. Launch an Instance with the Rancher AMI

Assuming you already have a .pem key, launch an instance and select the Rancher AMI.

2. Connect to Your Instance

Open a terminal and connect to your instance. Note that you should use rancher as the user, rather than root:

ssh -i "XXX.pem" rancher@ec2-XX-XXX-XX-XX.ap-southeast-1.compute.amazonaws.com
3. Verify the Rancher Server

The Rancher server should already be running. You can check by executing:

docker ps

If it's not running, download and start the server using Docker:

docker run -d -p 8080:8080 rancher/server
4. Configure Security Groups

Navigate to the Security Group tab in the AWS console and create a new one with inbound rules:

The rules should include:

  • Ports 22, 2376, and 8080/tcp for Docker Machine to provision hosts
  • Ports 500 and 4500/udp for the Rancher network
  • Ports 9345 and 9346/tcp for the UI
  • Port 80/tcp for the site you deploy
5. Assign the New Security Group

Select the instance, then navigate to Actions > Networking > Change Security Group. Check the new Security Group ID and assign it to your instance.

6. Access the Rancher UI

Open a browser and navigate to the Public DNS with port 8080, such as http://ec2-XX-XXX-XX-XX.ap-southeast-1.compute.amazonaws.com:8080.

You should see the Rancher UI:

7. Add Host Using AWS Credentials

To add a host with Amazon EC2, you'll need the Access Key and Secret Key. If you don’t have them, go to the AWS Console > IAM (Identity and Access Management) > Create New Users. Download the credentials.csv file.

Next, go to the Groups tab > Group Actions > Add Users to Group. Attach the policy by searching for "AmazonEC2FullAccess", check the box, and apply the changes.

8. Enter AWS Credentials in Rancher UI

Return to the Rancher UI and enter the newly generated Access Key and Secret Key from the credentials.csv file.

Finally, fill out the necessary information and you'll see your host up and running.

Postscript

To manage Docker's secret API keys, certificate files, and production configuration, you can try the beta Vault integration, depending on your specific needs.

  • in podcast
  • 3 min read

Launching RancherOS on AWS EC2

Welcome back to another episode of Continuous Improvement, the podcast dedicated to helping you enhance your skills and knowledge in the world of technology. I'm your host, Victor, and today we are diving into the world of RancherOS, a Linux distribution specifically designed for running Docker containers.

But before we dive in, I want to remind you to subscribe to our podcast wherever you listen to your favorite shows, so you never miss an episode. And if you have any questions or suggestions for future topics, feel free to reach out to us on our website or social media channels. Okay, let's get started!

Today, we're focusing on a step-by-step guide for setting up RancherOS on AWS. Now, there is an AMI available in the AWS Marketplace, but there are some additional configurations and security group setups that can be a bit tricky. And that's where this guide comes in as the missing manual. So, let's jump right into it.

STEP 1: Launch an Instance with the Rancher AMI. Assuming you already have a .pem key, go ahead and launch an instance and select the Rancher AMI.

STEP 2: Connect to Your Instance. Open a terminal and connect to your instance using SSH. It's important to note that you should use the 'rancher' user instead of root.

ssh -i "XXX.pem" rancher@ec2-XX-XXX-XX-XX.ap-southeast-1.compute.amazonaws.com

STEP 3: Verify the Rancher Server. Check if the Rancher server is already running by executing the following command:

docker ps

If it's not running, download and start the server using Docker:

docker run -d -p 8080:8080 rancher/server

STEP 4: Configure Security Groups. Head over to the Security Group tab in the AWS console and create a new security group with the appropriate inbound rules. These rules should include ports for Docker Machine, Rancher network, UI, and the site you deploy.

STEP 5: Assign the New Security Group. Select the instance and navigate to Actions > Networking > Change Security Group. Choose the new Security Group ID and assign it to your instance.

STEP 6: Access the Rancher UI. Open a browser and enter the Public DNS with port 8080, for example: http://ec2-XX-XXX-XX-XX.ap-southeast-1.compute.amazonaws.com:8080. You should now see the Rancher UI.

STEP 7: Add Host Using AWS Credentials. To add a host with Amazon EC2, you'll need the Access Key and Secret Key. If you don't have them, navigate to AWS Console > IAM > Create New Users and download the credentials.csv file. Attach the required policy to the user by searching for "AmazonEC2FullAccess".

STEP 8: Enter AWS Credentials in Rancher UI. Return to the Rancher UI and enter the newly generated Access Key and Secret Key from the credentials.csv file. Fill out the necessary information, and voila! You'll have your host up and running.

POSTSCRIPT: For those of you looking to manage Docker's secret API keys, certificate files, and production configuration, you can explore the beta integration of Vault based on your specific needs.

And that's it for today's episode of Continuous Improvement. I hope this step-by-step guide helps you navigate the process of setting up RancherOS on AWS. Remember, practice makes perfect, so don't be afraid to experiment and learn along the way.

Thank you for tuning in! Make sure to join us next time when we explore more exciting topics and dive deeper into the world of technology. Until then, keep improving and keep learning.

This has been Victor, your host of Continuous Improvement, signing off. Stay curious, my friends.

  • in zh
  • 2 min read

在AWS EC2上啟動RancherOS

RancherOS是一種為運行Docker容器而設計的Linux發行版。雖然AWS Marketplace已經有可用的AMI（Amazon Machine Image），但設置安全組和其他配置可能會有些棘手。這份指南就是缺少的使用手冊。

1. 使用Rancher AMI啟動一個實例

假設你已經有一個 .pem密鑰，啟動一個實例並選擇Rancher AMI。

2. 連接到您的實例

打開終端並連接到您的實例。請注意，您應該使用rancher作為用戶，而不是root：

ssh -i "XXX.pem" rancher@ec2-XX-XXX-XX-XX.ap-southeast-1.compute.amazonaws.com
3. 驗證Rancher服務器

Rancher服務器應該已經在運行。你可以通過執行以下命令進行檢查：

docker ps

如果它沒有運行，可以使用Docker下載並啟動服務器：

docker run -d -p 8080:8080 rancher/server
4. 配置安全組

在AWS控制台中，轉到Security Group選項卡並創建一個包含入站規則的新組：

規則應包括：

  • 端口22、2376和8080/tcp 供Docker機器分配主機
  • 端口500和4500/udp 供Rancher網絡使用
  • 端口9345和9346/tcp 用於UI界面
  • 端口80/tcp 用於您部署的站點
5. 分配新的安全組

選擇實例，然後導航到Actions > Networking > Change Security Group。檢查新的安全組ID並將其分配給您的實例。

6. 訪問Rancher UI

打開一個瀏覽器並轉到公共DNS的8080端口，如 http://ec2-XX-XXX-XX-XX.ap-southeast-1.compute.amazonaws.com:8080。

您應該會看到Rancher UI：

7. 使用AWS憑證添加主機

要使用Amazon EC2添加一個主機，您需要Access Key和Secret Key。如果您沒有它們，請前往AWS Console > IAM (Identity and Access Management) > Create New Users。下載credentials.csv文件。

接下來，前往Groups選項卡 > Group Actions > Add Users to Group。通過搜索"AmazonEC2FullAccess"來附加策略，選中方框，並應用更改。

8. 在Rancher UI中輸入AWS憑證

返回到Rancher UI，並從credentials.csv文件中輸入新生成的Access Key和Secret Key。

最後，填寫所需的信息，您將看到您的主機正在運行。

附言

要管理Docker的秘密API鑰匙、證書文件和生產配置，您可以根據您的具體需求嘗試使用beta版的Vault集成。

  • 2 min read

Deploying a Java Spring Server with a Docker Container

In this guide, I'll show you how to deploy a Java Spring server using Docker. Below are the steps to follow:

1. Launch an Ubuntu Server

For this demo, let's assume you have launched a server running Ubuntu 14.04. Install Docker using the APT repository:

sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates
sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

Open /etc/apt/sources.list.d/docker.list with your favorite text editor and add the following line:

deb [https://apt.dockerproject.org/repo](https://apt.dockerproject.org/repo) ubuntu-trusty main

Proceed to install Docker on the server:

sudo apt-get update
sudo apt-get install docker-engine
sudo service docker start
2. Build the Docker Image

Log in to Docker Hub (https://hub.docker.com/) and create a new repository. Then, in your terminal, run:

docker login

Enter your username and password when prompted.

In your local development Java Spring folder, create a Dockerfile with the following content:

FROM frolvlad/alpine-oraclejdk8:slim
VOLUME /tmp
ADD target/fleet-beacon*.jar app.jar
EXPOSE 8080
RUN sh -c 'touch /app.jar'
ENTRYPOINT ["java", "-jar", "/app.jar"]

To build the image, execute:

docker build -t username/repo-name .

Here, -t stands for "tag." Replace username and repo-name with your Docker Hub username and repository name. Also, don't forget the trailing dot.

Push the built image to your remote repository:

docker push username/repo-name
3. Pull the Docker Image

On your remote Ubuntu server, log in to Docker and pull the image:

docker pull username/repo-name

Run the container in the background:

docker run -d -p 8080:8080 username/repo-name

Here, -d means "detached," and -p specifies that all exposed ports (e.g., 8080) should be published to the host interfaces.

4. Set Up Nginx

Using the Vim editor, open /etc/nginx/sites-available/default and modify it as follows:

server {
  listen 80 default_server;
  listen [::]:80 default_server ipv6only=on;

  root /usr/share/nginx/html;
  index index.html index.htm;
  server_name localhost;

  location / {
    proxy_set_header X-Forwarded-Host $host;
    proxy_set_header X-Forwarded-Server $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass [http://localhost:8080/](http://localhost:8080/);
  }
}

Exit and save with :wq!.

That's it! Open a browser and navigate to your remote server's IP address; you should see the Java Spring page running smoothly.

5. Troubleshooting

If you encounter an issue with the Docker daemon connection, showing:

Cannot connect to the Docker daemon. Is the Docker daemon running on this host?

Run the following command:

eval $(docker-machine env default)

If you're testing locally and can't find your IP address, use this command to find it:

docker-machine ls

Feel free to leave a comment below if you encounter any other issues.

  • in podcast
  • 3 min read

Deploying a Java Spring Server with a Docker Container

Welcome to another episode of Continuous Improvement, the podcast where we explore tips and tricks for improving your development and deployment processes. I'm your host, Victor, and today we're going to dive into the world of deploying a Java Spring server using Docker.

To start off, let's assume you've already launched an Ubuntu server running Ubuntu 14.04. The first step is to install Docker on your server. Open up your terminal and follow these commands:

sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates
sudo apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

Next, we need to add the Docker APT repository to our sources list. Open up /etc/apt/sources.list.d/docker.list with your favorite text editor and add the following line:

deb [https://apt.dockerproject.org/repo](https://apt.dockerproject.org/repo) ubuntu-trusty main

Now, let's proceed with the installation of Docker on our server:

sudo apt-get update
sudo apt-get install docker-engine
sudo service docker start

Great! Now that Docker is installed, let's move on to building our Docker image. First, log in to Docker Hub at https://hub.docker.com/ and create a new repository. Once that's done, open up your terminal and run:

docker login

Enter your Docker Hub username and password when prompted.

Next, navigate to your local development Java Spring folder and create a file called Dockerfile. Inside the file, copy and paste the following content:

FROM frolvlad/alpine-oraclejdk8:slim
VOLUME /tmp
ADD target/fleet-beacon*.jar app.jar
EXPOSE 8080
RUN sh -c 'touch /app.jar'
ENTRYPOINT ["java", "-jar", "/app.jar"]

This Dockerfile sets up our Docker image with the necessary dependencies and configurations for running our Java Spring server.

Now, to actually build the Docker image, run the following command:

docker build -t username/repo-name .

Here, -t stands for "tag." Make sure to replace username and repo-name with your Docker Hub username and repository name. Don't forget the trailing dot at the end!

Fantastic! Our Docker image is built and ready to go. The next step is to push the image to your remote repository. Execute the following command:

docker push username/repo-name

This will push the image to your Docker Hub repository, making it accessible for deployment.

Now, on your remote Ubuntu server, log in to Docker and pull the image:

docker pull username/repo-name

This will ensure that the Docker image is available on your server.

With the image in place, it's time to run the container. Execute the following command on your remote server:

docker run -d -p 8080:8080 username/repo-name

The -d flag tells Docker to run the container in the background, and the -p flag specifies that port 8080 should be published to the host interfaces.

And just like that, your Java Spring server is up and running in a Docker container!

To complete the setup, we need to configure Nginx as a reverse proxy. Open up /etc/nginx/sites-available/default using the Vim editor. Modify the content as follows:

server {
  listen 80 default_server;
  listen [::]:80 default_server ipv6only=on;

  root /usr/share/nginx/html;
  index index.html index.htm;
  server_name localhost;

  location / {
    proxy_set_header X-Forwarded-Host $host;
    proxy_set_header X-Forwarded-Server $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass [http://localhost:8080/](http://localhost:8080/);
  }
}

Save the changes and exit the Vim editor.

And there you have it! Your Java Spring server is now successfully deployed using Docker and accessible through Nginx.

I hope you found this episode of Continuous Improvement helpful. If you encounter any issues or have any questions, feel free to leave a comment below the blog post. And remember, the key to continuous improvement is embracing new technologies and techniques. Thank you for listening and until next time, happy coding!