Deploying Docker images
by Mat Ryer, Mario Castro Contreras, Vladimir Vivien
Go: Design Patterns for Real-World Projects
- Go: Design Patterns for Real-World Projects
- Go: Design Patterns for Real-World Projects
- Credits
- Preface
- 1. Module 1
- 1. A First Step in Go
- 2. Go Language Essentials
- 3. Go Control Flow
- 4. Data Types
- 5. Functions in Go
- 6. Go Packages and Programs
- 7. Composite Types
- 8. Methods, Interfaces, and Objects
- 9. Concurrency
- 10. Data IO in Go
- 11. Writing Networked Services
- 12. Code Testing
- 2. Module 2
- 1. Ready... Steady... Go!
- A little bit of history
- Installing Go
- Starting with Hello World
- Integrated Development Environment - IDE
- Types
- Variables and constants
- Operators
- Flow control
- Functions
- Arrays, slices, and maps
- Visibility
- Zero-initialization
- Pointers and structures
- Interfaces
- Testing and TDD
- Libraries
- The Go get tool
- Managing JSON data
- Go tools
- Contributing to Go open source projects in GitHub
- Summary
- 2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns
- Singleton design pattern - having a unique instance of a type in the entire program
- Builder design pattern - reusing an algorithm to create many implementations of an interface
- Factory method - delegating the creation of different types of payments
- Abstract Factory - a factory of factories
- Prototype design pattern
- Summary
- 3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns
- 4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
- 5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
- 6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
- Template design pattern
- Description
- Objectives
- Example - a simple algorithm with a deferred step
- Requirements and acceptance criteria
- Unit tests for the simple algorithm
- Implementing the Template pattern
- Anonymous functions
- How to avoid modifications on the interface
- Looking for the Template pattern in Go's source code
- Summarizing the Template design pattern
- Memento design pattern
- Interpreter design pattern
- Summary
- Template design pattern
- 7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
- 8. Introduction to Gos Concurrency
- 9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
- 10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
- 1. Ready... Steady... Go!
- 3. Module 3
- 1. Chat Application with Web Sockets
- 2. Adding User Accounts
- 3. Three Ways to Implement Profile Pictures
- 4. Command-Line Tools to Find Domain Names
- 5. Building Distributed Systems and Working with Flexible Data
- 6. Exposing Data and Functionality through a RESTful Data Web Service API
- 7. Random Recommendations Web Service
- 8. Filesystem Backup
- 9. Building a Q&A Application for Google App Engine
- The Google App Engine SDK for Go
- Google Cloud Datastore
- Entities and data access
- Google App Engine users
- Transactions in Google Cloud Datastore
- Querying in Google Cloud Datastore
- Votes
- Casting a vote
- Exposing data operations over HTTP
- Running apps with multiple modules
- Deploying apps with multiple modules
- Summary
- 10. Micro-services in Go with the Go kit Framework
- 11. Deploying Go Applications Using Docker
- Appendix. Good Practices for a Stable Go Environment
- Bibliography
Now that we have contained our Vault service inside a Docker container, we are going to do some useful things with it.
The first thing we are going to do is push this to the Docker Hub so that other people may spin up their own instances or even build new images based on it.
Head over to Docker Hub at https://hub.docker.com and create an account by clicking on the Log In link in the top-right-hand corner and then clicking on Create Account. Of course, if you already have an account, just log in.
Now in a terminal, you are going to authenticate with this account by running Docker's login command:
docker login -u USERNAME -p PASSWORD https://index.docker.io/v1/
Ensure that you replace USERNAME and PASSWORD with your actual username and password of the account you just created.
If successful, you'll see, Login Succeeded.
Next, back in the web browser, click on Create Repository and create a new repository called vault. The actual name for this image is going to be USERNAME/vault, so we're going to need to rebuild the image locally to match this.
In a terminal, build the new repository with the correct name:
docker build -t USERNAME/vault
This will build the image again, this time with the appropriate name. To deploy the image to the Docker Hub, we use Docker's push command:
docker push USERNAME/vault
After some time, the image and its dependencies will be pushed to Docker Hub:
f477b97e9e48: Pushed 384c907d1173: Pushed 80168d020f50: Pushed 0ceba54dae47: Pushed 4d7388e75674: Pushed f042db76c15c: Pushing [====> ] 21.08 MB/243.6 MB d15a527c2ee1: Pushing [=====> ] 15.77 MB/134 MB 751f5d9ad6db: Pushing [======> ] 16.49 MB/122.6 MB 17587239b3df: Pushing [===================>] 17.01 MB/44.31 MB 9e63c5bce458: Pushing [==================> ] 65.58 MB/125.1 MB
Now head over to the Docker Hub to see the details of your image, or look at an example at https://hub.docker.com/r/matryer/vault/.
-
No Comment