{"id":56416,"date":"2023-01-14T22:48:27","date_gmt":"2023-01-14T17:18:27","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=56416"},"modified":"2024-01-02T17:42:03","modified_gmt":"2024-01-02T12:12:03","slug":"fooling-around-with-docker-cli-commands-with-postgresql-image","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/fooling-around-with-docker-cli-commands-with-postgresql-image\/","title":{"rendered":"Fooling around with Docker CLI commands with PostgreSQL image"},"content":{"rendered":"

C<\/span><\/strong>urrently, I am developing a side project wherein I wanted to use Postgres as my project database using its docker image. This blog is my brain dump of the docker basics I have learned so far, and I have attempted to break down the CLI commands I used or came across during the course of development for my own better understanding.<\/p>\n

We\u2019ll start with simple basics like:<\/p>\n

    \n
  1. Docker: A definition<\/li>\n
  2. Docker Image<\/li>\n
  3. Docker Container<\/li>\n<\/ol>\n

    Feel free to skip these sections if you know these concepts already. Finally, I\u2019ll explain how you can download Postgres images from the docker hub, and we will jump right into CLI Commands.<\/p>\n

    Note: Please note that this blog assumes that you have docker already installed in your system. If not, then you can download it from\u00a0here<\/a>.<\/p><\/blockquote>\n

    Docker: A definition<\/h3>\n

    Docker is an open-source project for building the shipping and running programs. It is a command line program, a background process and a set of remote services that simplifies your experience of installing, running, publishing and removing a software.<\/p>\n

    It accomplishes this by using something called\u00a0containers.<\/em><\/p>\n

    Docker Image<\/h3>\n

    An\u00a0image\u00a0<\/em>is a program bundled\/packaged together with the dependencies required to run that program.<\/p>\n

    Docker Container<\/h3>\n

    A\u00a0container\u00a0<\/em>is a running instance of an image. The running state of a container is directly tied to the running state of the program inside the container. Unlike virtual machines, Docker containers do not use any hardware virtualization.<\/p>\n

    \n

    Docker is not a hardware virtualization technology but it helps you use container technology already built into your operating system kernel.<\/p>\n<\/blockquote>\n

    <\/p>\n

    Run Postgres image locally using docker<\/h3>\n
    docker pull postgres:<version>\r\n\r\n#Example<\/span>\r\ndocker pull postgres:15.1\r\n\r\n<\/pre>\n
    You can checkout the available image versions at\u00a0https:\/\/hub.docker.com\/_\/postgres<\/a>.<\/p>\n
    Start the postgres instance on docker along with its Port Mapping:<\/p>\n
    docker run --name <container_name> -e POSTGRES_USER=root -e POSTGRES_PASSWORD=root -p 5432:5432 -d postgres:<version>\r\n\r\n#example:<\/span>\r\ndocker run --name myPostgres -e POSTGRES_USER=root -e POSTGRES_PASSWORD=root -p 5432:5432 -d postgres:15.1<\/pre>\n
    This command returns a long unique ID:<\/p>\n
    <\/p>\n
    Let\u2019s break this down:<\/p>\n
      \n
    1. run<\/code>\u00a0command looks for the image locally or remotely(docker hub<\/em><\/strong>\u00a0which is a public docker repository). If found,\u00a0run<\/code>\u00a0installs the image if it isn\u2019t already. Finally, it creates and starts the container immediately.<\/li>\n
    2. -d<\/code>\u00a0flag is used for telling the docker to run the container in the background or detached mode<\/li>\n
    3. -e<\/code>\u00a0flag is used for passing the environment variables if we want to customise the containers by passing environment variables like\u00a0POSTGRES_USER<\/code>\u00a0or\u00a0POSTGRES_PASSWORD<\/code>\u00a0. Similarly, the environment variable\u00a0POSTGRES_DB<\/code>\u00a0can be used to define the name of the database. If name is not defined, the\u00a0POSTGRES_USER<\/code>\u00a0is taken as default name for database.<\/li>\n
    4. 5432:5432<\/code>\u00a0is the port mapping of the running instance. Docker container runs in a separate virtual network which is different from the host network that we are on. So we cannot simply connect to the postgres server running on the port 5432 of the container network unless we tell docker to create a kind of a bridge between our localhost network and the container\u2019s network. We do that by using the\u00a0-p<\/code>\u00a0flag (which means port), then specify the port of the host network followed by a colon, then the corresponding port of the container network :
      \n-p <host_network_port>:<container_network_port><\/code>.\u00a0Example:<\/strong>\u00a0-p 5432:5432<\/code>\u00a0.
      \n<host_network_port><\/code>\u00a0and\u00a0<container_network_port><\/code>\u00a0cannot necessarily be the same but we can set the same port for the sake of convenience while developing locally.<\/li>\n<\/ol>\n
      A container is an instance of the application contained in the image which can be started by\u00a0docker run<\/code>\u00a0command. We can start multiple containers from one single image.<\/em><\/p><\/blockquote>\n
      Run the following command to list the containers:<\/p>\n
      \/\/This will list all the running containers\r\ndocker ps \r\n\r\n\/\/or \r\n\r\n\/\/This will list all the containers regardless of their status(active or inactive)\r\ndocker ps -a<\/pre>\n

      \nVoila ?, our container is running!<\/p>\n
      Connecting to Postgres container console:<\/h3>\n
      Now that the postgres server is ready, we can connect to it and access its console by using the\u00a0docker exec<\/code>\u00a0command as follows:<\/p>\n
      \/\/ syntax: docker exec<\/span> -it <CONTAINER_NAME_OR_ID> <CMD> -U <USER>\r\n\r\ndocker exec<\/span> -it myPostgres psql -U root<\/pre>\n
      The docker exec<\/code>\u00a0command runs or \u201cExecutes\u201d a new command in a running container.<\/p>\n
      Lets take a deep dive:<\/p>\n
        \n
      1. -it<\/code>\u00a0flag tells docker to run the command as an interactive TTY**(terminal = tty = text input\/output environment)** session<\/li>\n
      2. psql<\/code>\u00a0will enable us to access the postgres console<\/li>\n
      3. -U<\/code>\u00a0flag tells the\u00a0psql<\/code>\u00a0that we want to connect with the\u00a0root<\/code>\u00a0user<\/li>\n
      4. In localhost, postgres container doesn\u2019t need a password as postgres image sets up\u00a0Trust<\/code>\u00a0Authentication mechanism for authenticating a user. However, a password will be needed if connecting from a different host or container.<\/li>\n<\/ol>\n
        <\/p>\n
        That worked well!! \ud83d\ude42<\/p>\n
        Connecting to the container shell:<\/h3>\n
        The shell for postgres running container can be accessed through the following command:<\/p>\n
        docker exec<\/span> -it <CONTAINER_NAME> <EXECUTABLE>\r\n\r\n#example<\/span>\r\ndocker exec<\/span> -it myPostgres \/bin\/sh<\/pre>\n
        This gives us access to all the linux commands.<\/p>\n
        \n
        \/bin\/sh<\/code>\u00a0is an executable representing the system shell and usually implemented as a symbolic link pointing to the executable for whichever shell is the system shell. The system shell is basically the default shell that the script should use.<\/em><\/p>\n<\/blockquote>\n
        <\/p>\n
        woohooo.. I can run linux commands on my container shell<\/p>\n
        Using shell to execute database commands:<\/h3>\n
        We can use the shell to execute the database commands<\/p>\n
        createdb --username=<USERNAME> --owner=<USERNAME> <DB_NAME>\r\n\r\n#Example<\/span>\r\ncreatedb --username=root --owner=root test_database<\/pre>\n
        <\/p>\n
        I can see a newly created test_database on \u201cTablePlus<\/a>\u201d database list<\/p>\n
        Just like\u00a0createdb<\/code>\u00a0, you can\u00a0drop<\/em> your database using the command dropdb <DB_NAME><\/code>\u00a0inside the shell.<\/p>\n
        <\/p>\n
        <\/p>\n
        You can use the\u00a0exit<\/code>\u00a0command to come out of the container shell.<\/em><\/p><\/blockquote>\n
        Now from outside the container, we chain the\u00a0createdb<\/code>\u00a0command directly with the\u00a0docker exec<\/code>\u00a0command:<\/p>\n
        docker exec<\/span> -it <CONTAINER_NAME> createdb --username=root --owner=root <DB_NAME>\r\n\r\n#Example<\/span>\r\ndocker exec<\/span> -it myPostgres createdb --username=root --owner=root test_database<\/pre>\n
        Similarly, other database operations can be chained with\u00a0docker exec<\/code>\u00a0command like:<\/p>\n
        #Example 1<\/span>\r\ndocker exec<\/span> -it myPosygres dropdb test_database\r\n\r\n#Example 2 : if you want to access postgres console of test_database<\/span>\r\ndocker exec<\/span> -it myPostgres psql test_database<\/pre>\n
        <\/p>\n
        Some more useful commands:<\/h3>\n
          \n
        1. If you want to stop a running container, you can use the following command:\u00a0docker stop <CONTAINER_NAME_OR_ID><\/code><\/li>\n
        2. If you want to run a container again, you can use the following command:\u00a0docker start <CONTAINER_NAME_OR_ID><\/code><\/li>\n
        3. If you have stopped your container and you want to completely remove it, you can run the following command:\u00a0docker rm <CONTAINER_NAME><\/code>\u00a0. This command will not work unless you have stopped your container.<\/li>\n<\/ol>\n
          Difference between docker create, start and run:<\/h3>\n
          Here\u2019s what these commands do:<\/p>\n
            \n
          1. docker create<\/code>\u00a0command<\/strong>\u00a0creates a fresh new container from a docker image. However, it doesn\u2019t run it immediately.<\/li>\n
          2. docker start<\/code>\u00a0command<\/strong>\u00a0will start any stopped container. If you used docker create command to create a container, you can start it with this command.<\/li>\n
          3. docker run<\/code>\u00a0command<\/strong>\u00a0is a combination of create and start as it creates a new container and starts it immediately. In fact, the docker run command can even pull an image from Docker Hub if it doesn\u2019t find the mentioned image on your system.<\/li>\n<\/ol>\n
            Note of thanks \u2764\ufe0f<\/h3>\n
            Thank you for stopping by. Hope, you find this article useful. If you do, please\u00a0follow me<\/em><\/strong><\/a>\u00a0on medium. That will truly encourage me to put out more content.<\/p>\n
            P.S.: If you feel something can be improved or lacks proper explanation, drop me a note in the comment box or mail me at\u00a0shiva.chaturvedi91@gmail.com<\/a>. After all, you can teach me a thing or two as well.<\/p><\/blockquote>\n
             <\/p>\n
            <\/div>","protected":false},"excerpt":{"rendered":"
            Currently, I am developing a side project wherein I wanted to use Postgres as my project database using its docker image. This blog is my brain dump of the docker basics I have learned so far, and I have attempted to break down the CLI commands I used or came across during the course of […]<\/p>\n","protected":false},"author":1535,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":5},"categories":[1174,2348,4839,1],"tags":[1892,1883,5080,942,2591],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56416"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1535"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=56416"}],"version-history":[{"count":4,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56416\/revisions"}],"predecessor-version":[{"id":59777,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56416\/revisions\/59777"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=56416"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=56416"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=56416"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}