What is Reddit's opinion of
Docker?
From 3.5 billion Reddit comments
➔ Docker website
By popularity on Reddit, this Service is:
100 reviews of this app found across Reddit:
Notice how 2X nodes are distributed as Docker images. Docker images are easy to deploy cloud platforms such as Amazon AWS, Microsoft Azure, Digital Ocean and many others.
This means that we can likely soon see hoards of 2X nodes coming live from cloud services, many of which will be running in the same data center, on the same physical machine and even within the same virtual machine.
Deploying nodes like this does nothing in terms of decentralization of the network. It just artificially inflates the 2X node count.
It is sad to see to which great lengths Jeff Garzik, Coinbase and the DCG are prepared to go and deceitfully keep up appearances of support. Not to mention the money wasted and the predictable damages to the Bitcoin community of which many unsuspecting members are inevitably going to be duped.
It is a despicable display of disrespect to the Bitcoin community and they should be very, very ashamed of themselves.
Docker, along with a few service containers, makes a fast and slick development environment. There are a few examples and tutorials out there for its use. Here's one: https://docs.docker.com/samples/library/php/
I've tried looking on Docker's website and I'm having trouble decoding what they're trying to portray that their software/IT solutions so. Anyone have a clear explanation of what this is supposed to do?
Edit: So apparently (after further research) Docker is like a box that has all the normal necessary stuff for an application to run on a given set of hardware. At least that's what I'm grasping (correct me if I'm wrong). I'm gonna do a little more research because I'm genuinely curious as to what this does.
Edit 2: Ahhhhhhh, I understand now. Docker Swarm is a type of protocol that can link multiple computers together and use all of their resources together. Say you wanted to render a very large file in AutoCAD, or something in After Effects. You would use something like Docker Swarm and combine all the computing resources on all of your computers together to distribute load, making the process nor only faster, but more efficient. At least that's what I'm gathering from here.
Someone correct me if I'm wrong because I've always wondered how those big huge move studios can render an entire movie such as The Jungle Book (something that would take years to render on even the most advanced supercomputer) can be done in a few weeks.
Edit 3: Thanks everyone that replied for the explanations! For the correct explanation, see the replies to my comment.
> That's gigantic.
2 meg is gigantic but I'm being sarcastic? Is this real life?
It's trivial compared to using something like Docker for deployment but people do it just to overcome the issues of replicating run environments.
Here's a quick rundown:
- Docker defines a standard way to package up software - along with all dependencies - into a runnable image.
- The company provides a Hub and a community to publish, find and download images for all kinds of software.
- Docker makes it easy to run many applications as containers on a single OS. You get fast startup, fast shutdown and fair allocation of resources.
- It solves all the problems around networking that come up when you try to run lots of services on a single OS.
Why this is huge:
- Microsoft will now build a container capability into Windows. This feature has been missing (compared to Linux) for years. This change alone would be a huge announcement.
- Microsoft are showing commitment to important open source projects invented outside Microsoft - first Kubernetes and now Docker. They're demonstrating a new forward-thinking, developer-centric approach.
- Microsoft are not demanding stewardship. Docker, Inc. will manage the source code for the engine and MS will contribute.
If you actually gave a shit about learning, you could have gone to docker.com and learned about how docker provides virtualization containers for server deployment.
But you didn't because in all actuality you don't give a shit about docker.
Hell, docker spent time on their website to sell it to technically inept CEO's for their companies. But despite this, it was beyond you to
- click on the link
- discover the project is docker
- go to the docker homepage (literally docker.com)
- read and learn
So if you didn't care in the first place, why ask what docker is?
Yes it does (support virtualization) and yes docker will (very soon) work on those.
It’s still unclear if it will support x86 containers (through emulation) in addition to arm64.
https://www.docker.com/blog/apple-silicon-m1-chips-and-docker/
it sounds like you have a fundamental misunderstanding about what docker is even trying to do, much less what it does.
it is a suite of tools around managing linux containers. https://www.docker.com/whatisdocker/
Docker on Windows is more of a hybrid. They use HyperV virtualization to provide a Linux kernel and run Linux containers under that. https://www.docker.com/docker-windows
I neglected to acknowledge that Docker can run on Windows and was discussing only the LInux hosted side.
> but without the massive headaches of setting up and maintaining a graphical Linux desktop
I see you have not touched any desktop Linux distributions in the last ~10 years. They ship with complete desktop ux, and what I can speak for is Ubuntu and Debian, those had incredibly smooth user interfaces with all the things you need.
> brew
This is a simple package manager. You can use basically any package manager on your Linux as well, and they can easily be separated, but what you really should be looking for is docker.
> Command/Super instead of Ctrl for system shortcuts (...) since it means out of the box there's zero conflict between terminal control codes and the rest of the OS.
This is not anything new, I have never seen any distros having conflicts with terminal. Other than the generic keyboard commands (copy, paste, select all) the shortcuts are on either command or alt. This is so old that even Windows 7's shortcuts were fully on the command(windows) key.
> I don't know of any Linux equivalent to iTerm2
There are but this just comes down to taste and what you are used to.
Actually at this point is neither OS nor hardware.
The Developer Transition Kit had an A12Z that did not have virtualization extensions enabled. That shouldn't have stopped the Docker team from being able to port onto Apple's hypervisor framework (frankly, something I'm surprised they hadn't already done, and should have done some time ago), but it would have prevented testing on the ARM platform. M1 does have those extensions enabled.
Right now, it's mainly upstream dependencies that are holding them back. Go will not support Apple silicon until 1.16 due in February (though I expect Docker can start working on it now -- as far as I can tell everything needed for Go to support Apple Silicon is on master now).
They also call out Electron, which is already shipping beta versions with Apple silicon support, but again, they probably don't want to make a production release on prerelease upstreams, not to mention it's a major version so there are probably breaking changes that need to be worked through.
Finally... they actually need to get machines to test on.
So yeah, I'm as antsy as the rest of you... but these things take time, and Docker is in a bit of a unique position simply because it uses virtualization, which is pretty much the one thing that Rosetta can't help with.
The blog post has more details: https://www.docker.com/blog/apple-silicon-m1-chips-and-docker/
Well if you go to docker.com you will see the text below explaining their new licensing model for Docker Desktop.
Our Docker Subscription Service Agreement includes a change to the terms for Docker Desktop
- It remains free for small businesses (fewer than 250 employees AND less than $10 million in annual revenue), personal use, education, and non-commercial open source projects.
- It requires a paid subscription (Pro, Team or Business), for as little as $5 per user per month, for professional use in larger businesses.
- The effective date of these terms is August 31, 2021. There is a grace period until January 31, 2022 for those that will require a paid subscription to use Docker Desktop.
- The Docker Pro, Docker Team, and Docker Business subscriptions now include commercial use of Docker Desktop.
- Check out our FAQ for more information. Or read our latest blog.
It’s a software that lets you run lightweight applications. Instead of copying your code and running it on a server, you copy the code to run the application and the application code. This gets around errors where “it worked on my machine” because I installed library X and you must be missing that. Since you are also including X and all the code to run your app instead of just your code.
This is not a full summary of docker but if you want to learn more see docker’s documentation on containers https://www.docker.com/resources/what-container
Yeah, as a software developer, that page was clearly not written for me. The main problem with going to docker.com is that the real answer I need to "What is Docker?" is "It's basically just a tool for managing Linux containers (LXC)." But docker.com can't actually say that on its home page if it wants business types to pony up big bucks.
Tellingly, the "What is Docker?" page doesn't even contain the word "Linux," let alone "Linux containers."
Define "bad".
The CPU architecture is slightly different, but compatible, so beside the performance difference, it's no biggie. Yet if pods run on the Pi3, they'll be slower than if they run on the Pi4. That's bad for CPU intensive programs.
It's a good educational exercise to work around this (mark the 3b as "low priority" or put special non-CPU-intensive workload on it), but you don't gain much here in practical terms. Some would thus see this educational value as "wasted time". In reality you try to keep all nodes identical. Simplifies management a lot.
There's more educational value if you add in an even older RPi. Or x86_64 nodes. Then the binaries are no longer compatible. See multi arch images. Again: you'd usually not do this in reality.
2 Pi4 and 1 Pi3b will work. So I guess that counts as "not bad". It's not good either (3 Pi4 would be absolutely ok), but for the sake of having 3 nodes to set up and test a HA setup, it'll do.
I don’t use docker on the Mac a regular basis, but it looks like Big Sur is officially supported and there’s a tech preview out for Big Sur on ARM Macs. Are there game-breaking bugs that aren’t readily apparent?
All of these seem very generic, with the exception of the bottom center logo which is (too) strongly reminiscent of the Aperture Laboratories logo.
That said, just throwing this out there....
How about something whimsical? Like the Docker logo. I say whimsical because when I saw your studio name I immediately thought of a brain with a party hat since it looks like a portmanteau of "celebrate" and "cerebral" (which is what I assume you were going for with the name). Just sayin'. I think you could evolve some distinctive branding around a concept like that, and given that you are a game development studio I don't think whimsy entirely inappropriate for a brand.
I don't think it's fair to say that Google isn't contributing. I've personally been involved since the beginning (https://www.docker.com/blog/community-collaboration-on-notary-v2/) and have spent a substantial amount of time giving feedback from the perspective of a registry and client maintainer. We're also working on some changes to the image-spec and distribution-spec that (if adopted) could enable the notary v2 prototypes to be portable across real registries.
I'm just not heavily involved in refining the requirements documents, because that's not really interesting to me as an engineer, and time is a limited resource :)
> Just wanted to learn some docker and kubernetes
Windows Docker Desktop has a built in Kubernetes setting that you can toggle to run K8:
https://www.docker.com/blog/docker-windows-desktop-now-kubernetes/
tl;dr: There's nothing to worry about here.
All it is is a Dockerfile, and all the files needed inside of the docker environment.
The Dockerengine is a way to isolate applications (like PHP, or Python) in their own environment. These environments are called 'containers'. All this does, is it creates a virtual environment, installs the necessary software (like Apache, opcache, mongodb and Redis) inside this environment, so your computer won't be affected.
Only the volumes parts in docker-compose.yml, will affect your computer a little bit. Basically they will place files that are used inside the container, on your computer, outside of the container. This gives developers / users, easy access to configuration files, and other files, without having to go inside of the container.
More explanation: https://www.docker.com/resources/what-container
The Docker Lab & Tutorials are a good start. https://www.docker.com/play-with-docker
The point of docker is that you can build a small enclosed environment that has exactly what you need, and can then be replicated where you need it. That way the testing environment & the deployment environment are exactly the same so you never end up with the "It works on my computer" ( but not on the server because of configuration differences ).
I hope that helps ...
MacOS Server has been stripped to the bone, Docker won’t be going native for a while, and in general server applications have not been a priority for Apple in at least a decade. I don’t say that this can’t ever change, but folks won’t be quick on the uptake for this use case.
Have you tried the docker tutorial? Last week I also set out to learn docker, the tutorial really helped explaining things. It shows how to setup volumes, so that it mounts your folder to the container for developing purposes.
Outside of the steps, you are going to need Docker to follow with the setup.
​
Along with that, you need to set MetaMask to use a custom RPC: https://goerli.prylabs.net
I would recommend setting that in MetaMask and then restart your browser or open a new session.
boot2docker is long gone. Docker for Mac uses a Linuxkit VM running in xhyve via HyperKit - there's a basic architecture diagram on this page: https://www.docker.com/docker-mac
I think you're right that you'll need to access the VM to deal with filesystem stuff though. There's some info about accessing the VM here: https://forums.docker.com/t/is-it-possible-to-ssh-to-the-xhyve-machine/17426/10
Personally, I would ask this question the other way around:
What services would you rather run in a container?
The thing that trips up a lot of people new to this kind of thing is that while containers have use cases, they're not just something that should be deployed willy nilly. Linux is designed for multi-tasking, you can have hundreds of services running on a normal host without any problems. Containers provide certain features and conveniences, but shouldn't be the default for a new service. Check the official Docker site list of use cases for some examples of why you'd use containers.
For example, there's almost no reason to run a single always-running nginx server serving basic web pages in a container. On the other hand, if you wanted to spin up ten nginx servers to each run minor variants of a customized module to test how stable they were, that's a great container use case.
I wouldn't run most of the stuff you've listed in containers unless you just really want to mess with containers. :) FreeIPA and DNS will probably be much easier to configure as normal anyway.
Docker is a containerization application that allows for packaging and deployment of applications and their dependencies. It's really a Linux thing, but can run on Windows. We're starting to look at using it for dynamic on-demand deployment of servers and systems for data analytic solutions we develop for client projects. If extra servers or nodes are needed, they can be spun up and configured for the application, and then taken down after. Docker ensures that the the software we deliver will behave the same every time, regardless of the environment the client runs.
- You can have private repositories on Docker Hub, but only on the paid plans: pricing. The images are still hosted on the Docker Hub though, so in case their auth system fails at any point, your data might leak. However, the Docker Registry software is FOSS, so you may consider hosting your own
- You always push pre-built images to any docker registry, whether it's the Hub or a self-hosted one, I'm not sure what you mean by that.
That's the idea of VMs, to decouple from the hardware. And containerised apps go one step further and decouple from the original VMs so that the apps can run on different VM environments. See here for more explanation: https://www.docker.com/resources/what-container
Docker itself runs very well on ARM / ARM64. Docker images typically contain compiled code, so the same caveats apply: if the code inside the container is compiled for x86-64 then it will only run on an x86-64 processor, likewise ARM.
Docker Hub supports many architectures, here are the public ARM64 images: https://hub.docker.com/search?architecture=arm64&source=verified&type=image
The number of public images for ARM64 is several orders of magnitude smaller than there are for x86-64, but it's an industry transition that is well underway. The "library" containers for the most important things you need, like Go, Node, Ruby, Python, and basic Linux images like Alpine, Debian, Ubuntu, Red Hat, Fedora, etc. are all available in ARM64 already.
Docker Desktop supports cross-compiling the same Dockerfile to architectures other than the one in your local development machine: https://www.docker.com/blog/multi-arch-build-and-images-the-simple-way/
As above, this is still not super easy and has some pitfalls, but the issues are getting worked through as ARM64 adoption continues.
What you say is true about running containers in a non linux environment such as BSD and Windows since it has to create a virtual kernel for the containers to use. Its a good thing you brought that up because I forgot to mention it since most of my servers are running a linux based OS, have an upvote. As far as maintenance it's only hard if your doing everything manually without the assistance of any other tools. That can also be said for virtual machines too if you had to go into them manually and run updates on each one yourself. There are tools that allow for easy management of containers. One tool that can help with that is portainer which is what OP is using. Another one that google create and opensource that is based on the propriety framework that they use to manage their containers is Kubernetes. Google themselves even use containers for all their services such as Gmail, Youtube and even the google search page Source. With all those tools its easy to manage your containers even if they are split up in different servers, there also exists tools that can be used to manage virtual machines to make it easier to manage and people should be utilizing those too. If you want to read up more on containers and why they are useful that google source has some nice information on it.
AFAIK the Docker For Windows product uses only Hyper-V. There is (was?) some other versions of docker on windows which could use VB but were less transparent or seamless to use.
https://www.docker.com/docker-windows
The old Docker Toolbox:
If you have good social and communication skills, you'll find tech companies begging to hire you for technical sales and marketing roles. In particular, look at a role called "sales engineer" e.g. like this one https://www.docker.com/careers/sales?job-id=488746
You can set up an Xpenology build if you like the Synology interface. This will have Docker support and you can install VirtualBox with phpVirtualBox. You can even generate working Serial for it to work with MyDS. PM if you want help with this.
I have Xpenology on ESXi build with passthrough on my SAS card. Used to run FreeNAS for 2 years and swapped it for Xpenology as soon as i learned it existed. (Have nothing of value on my drives, so no need for ZFS). Coucpotato, Sickrage, Transmission and Plex running just as well on Xpenology as it did on FreeNAS. Other alternative is OpenMediaVault. Have no experience with this though.
This is going to be overkill, but have you thought about segregating your apps through Docker? I guess I just wanted to share this technology because it's really helpful for hosting, especially in small server setup environments. I use dokku to manage the different web applications running on my VPS and it's been great. dokku doesn't scale very much, but if you're hosting on a single VPS, it makes it really easy to manage multiple web apps.
https://www.docker.com/blog/released-docker-desktop-for-mac-apple-silicon/
I have an M1 MBP. When it was released, Docker was not supported on it at all.
They added support in Rosetta and now. looks like they released a native version on August 15.
I stand corrected and this is good news for me.
Generally for Docker, the advice is to use personal access tokens where possible to avoid your main Docker hub account credentials being held in the clear.
For Docker for Windows/Mac they leverage the credential store on each platform to protect your creds, but (AFAIK) on Docker engine on Linux they don't, so it's important to a) use a personal access token and b) make sure you protect access to that file.
As tempting as it is to assume we're all familiar with that problem, you'll get more help if you act as if you're the first one to see it.
The only problem that I know of regarding Docker on Fedora has been that since Fedora switched to a cgroups v2 configuration, Docker hasn't worked because it doesn't support cgroups v2. They released a version that does in December, and I'd expect Docker to work on a default Fedora configuration since then:
https://www.docker.com/blog/introducing-docker-engine-20-10/
(Though, to be clear, I prefer the security model used by podman, so I don't use Docker.)
> LS.io's pull limit was reached
Nope. The limit is applied to the user who downloads the image.
> Rate limits for Docker image pulls are based on the account type of the user requesting the image - not the account type of the image’s owner.
Perfect questions! Kubernetes helps you run containers in production. You might have heard of Docker which runs containers, and which Kubernetes is built upon. You can think of containers as a bundle with everything required to run your app. In this instance, the WordPress container includes Apache, PHP, and all the PHP files that make WordPress run. The nice thing is that for a lot of popular software, the owners have built container images like the one we're using in the example (WordPress Docker Image) so you can launch it into production with a minimal amount of configuration. No need to manually set up Apache, PHP, decide what kind of server to set it up on, etc. The same goes for MySQL.
So in this demo, we are taking both of those images and telling Kubernetes to run them on a cluster of many servers. Kubernetes does the hard work of figuring out where to run your container and restarting in the event of any failures (for example, if a hard drive dies, Kubernetes will move your container to a healthy server).
While someone running a single wordpress blog alone might not need it, its a very cool tool to learn, especially if you want to run WordPress along side a few other personal blogs / sites / etc. Each might have its own unique webserver and config, but at the end of the day the server running it doesn't care, as all that is taken care of inside the container.
- Install docker.
- Run controller in this container.
- Never worry about software dependencies again
Basically stuff like Docker. A halfway house between running apps natively on a box and running them in their own VM.
Quoth their website: >Containers are a way to package software in a format that can run isolated on a shared operating system. Unlike VMs, containers do not bundle a full operating system - only libraries and settings required to make the software work are needed. This makes for efficient, lightweight, self-contained systems and guarantees that software will always run the same, regardless of where it’s deployed.
Docker for windows has two options, I think: One using Hyper-V management to run a small linux VM (https://docs.docker.com/docker-for-windows/), and one to use virtualbox to run a small linux VM (https://www.docker.com/products/docker-toolbox). If you open the Hyper-V manager, you'll probably see something there for the linux VM.
What that blog is talking about is the Windows 10 feature 'Containers' that run windows-based images only (https://msdn.microsoft.com/en-us/virtualization/windowscontainers/quick_start/quick_start_windows_10?f=255&MSPPError=-2147217396).
I think windows Server 2016 has two Container service modes, and one of those will enable Linux images via VMs, while the other will act like the Windows 10 one and work more like the 'Linux container on Linux' docker setup, just with Windows sharing the kernel and such.
Docker the company has created what they call the 'Universal Control Plane', which is now in beta: https://www.docker.com/universal-control-plane I checked it out, and it seems really great - even better than tutum I think. But we are currently using mesosphere's DCOS in production and it's a great solution, not just for docker. They have a free community edition that takes 5 minutes to deploy to AWS via a cloud formation template. I suggest checking it out ( warning: the default templates use m3.xlarge which are very costly, you can modify the template file to just use t2.micros while testing): https://docs.mesosphere.com/install/awscluster/
I think you should have a look at tools like vagrant or docker.
Vagrant is VM manager, it allows you to configure your desired environment and its built on top of existing virtual machines (VirtualBox, VMWare,etc). The problem with is the required overhead.
Docker is different because it shares the kernel host. Here is a quick description from the website: > The Docker Engine container comprises just the application and its dependencies. It runs as an isolated process in userspace on the host operating system, sharing the kernel with other containers. Thus, it enjoys the resource isolation and allocation benefits of VMs but is much more portable and efficient.
So, docker might be what you are looking for.
Docker Engine is open source.
Docker Desktop is a product that contains Docker Engine and a bunch of other stuff to run it on OSX/Windows. If you'd like to create your own version of it that includes Engine and other components, you can. You're also free to install WSL or another hypervisor, set up a Linux VM, and install Docker Engine inside of it. You can also use Docker Desktop for free for personal use or if your business is under the limits: https://www.docker.com/pricing/faq
Open source comes in two flavours: free speech, and free beer.
Docker Desktop / Docker Community Edition is open source, and free to use. Like free speech.
Registration for a Docker Personal account is part of the "cost" of being able to download a pre-built version of Docker Desktop. https://www.docker.com/blog/updating-product-subscriptions/
I believe it’s because they’re trying to monetize it. I haven’t been following it since I don’t use that tool, but my company is going through an audit to get people stop using it since it’s no longer free for us.
Edit: https://www.docker.com/blog/updating-product-subscriptions/
never used it but a very popular example of a container is docker (that link says what a container is) and singularity just looks like another container flavour (maybe specific to HPCs?)
> isolating each service into it's own system user with no permissions beyond it's own files, and access to nothing but what is required for functioning, should limit how much damage a compromised application is able to do
I cannot emphasize how on the ball this point is. If you're exposing jellyfin to the internet, definitely make sure that you've got restirctions and isolation on it. That also would include not reusing passwords if you can help it.
User isolation is good and the easiest to do, but if you can spare the compute overhead consider running Jellyfin in its own VM (remember unless you've opted into this on windows containers or are running with very specific configs that docker containers aren't vms). That way if a vulnerability in jellyfin or the stack it depends on is ever exploited the attacker has won a small vm with access to some media.
Octoprint is not designed to handle multiple 3D printers.
But, if you're willing to tinker, you can use Docker and the dockerized version of Octoprint to run two instances of Octoprint on the same Raspberry Pi
Homebrew has some issues. If you use this to manage the various CLI tools you use.
The normal install script for it doesn’t work. There’s some workarounds to get it installed, though.
https://andrewbarber.medium.com/how-to-install-homebrew-on-your-arm-based-mac-3660eb5f0b38
Then there’s known problems with some formulae.
https://github.com/Homebrew/brew/issues/7857
Docker is the other major issue for developers. It doesn’t work.
https://www.docker.com/blog/apple-silicon-m1-chips-and-docker/
3 things to do:
- remove installed docker and use docker-ce from https://www.docker.com
- switch firewall to iptables backend
- if it’s still not enough, switch to cgroups v1 (https://www.linuxuprising.com/2019/11/how-to-install-and-use-docker-on-fedora.html)
I use fedora 32 and docker daily without issues thanks to this.
I wonder how accurate that is vs. just not knowing a better setup/more modern setup.
For example, could it be run on a *nix server? How does it play with Docker or other containers?
The easiest ways to run Ubuntu for a service or group of services, to test code from your host: VirtualBox or Docker. Though, you might not need Ubuntu to run the services and programming, as many have solutions for multiple operating systems.
Anything 'container' and 'docker' refers to the concept of containerization and containerized applications. While an entirely correct parallel: A good first way to think about it is as micro-VM's. docker themselves give a good explanation.
'Transformations' in the context of RabbitMQ usually mean an application that can take messages from RabbitMQ (Or a similar service), transform them to a different format, and put them back on a different message queue. There's a good explanation here, though this resource does presume you've read up on RabbitMQ already.
If it's an intern position I can't imagine they'd require a huge amount of experience with the tools listed.
Some previous scripting/programming experience as well as experience with Linux (Ubuntu server for instance) would probably be what they're looking for in terms of hands-on tooling experience.
I've been a programmer with a penchant for Linux for almost ten years now and I still have only scratched the surface of what's going on in the devops world at the moment. Especially since the boom of cloud technologies and container platforms it's so hard to keep up with everything.
If it's in a couple of weeks I'd say try to get literate in the basics. Read through some the services Amazon Web Services offers ( https://aws.amazon.com/ ) look into what Docker ( https://www.docker.com/_ is and get to know about containers and VMs (and what the difference is so you don't tread on sensitive nerd toes by confusing the two terms :P).
Have a bash at Linux ( Docker would be a great way to spin up a Linux machine to play around with while also getting to know about containers).
I'm in Europe so things are different here. But generally when we look for people to fill positions, at least where I work, we aren't looking for the longest CV but for someone who is willing to learn and has shown initiative in improving themselves. If you got those two qualities then we can teach you the rest.
In the beginning it can be overwhelming but DevOps work is fkn fun after the steep initial learning curve. Good luck!
That indeed sounds like a hard nut to crack for your users...
You could automate the whole installation procedure in a script, but it might be a very complicated one as you will probably have to take care of a lot of possible 'special cases' (different versions of stuff already installed etc...).
And even if you succeed in creating such a script (and it can be done) you're still faced with (at least) two risks:
- The versions of software/libraries/etc you install might break other apps on the user's system that depend on 'older' versions of those.
- Users may (for whatever reason) update components in the future, which then may break your application.
In short, a support hell you probably want to avoid...
You could also take another route... Docker
This enables you to create (upfront) a self-contained environment with all the stuff you need, pre-compiled etc...
You can then simply distribute this container to the users. All they have to do to use the application is to start-up the container.
Oh yeah, of course the users need to have Docker installed, but that is a pretty straightforward one-time action.
If you make a Docker container with your app and your chosen JVM, people won't have to install the JVM on their machines and open themselves up to the security risks in doing so, and you won't have to worry about incompatible Java versions.
Docker is a program that allows people to install an application and all of its dependencies into one file, that others can then install on their computers in one simple step. Docker allows that application to run as if it were a separate machine, isolated from everything else on your computer. There's a lot more to it than that, but that is the ELI5 version.
You may wish to consider something like SELinux Sandboxes or maybe even a Docker container for the code that you execute, so that your exec code isn't so dangerous.
No.
https://www.docker.com/products/use-cases
You can actually run docker containers in a vagrant machine. Not one single person who has responded to this thread seems to understand what a container is.
First of all, I'd try to get this all working locally first before you add the cloud to the mix.
This should give you the stack you need: https://www.docker.com/toolbox
Once you've got that installed, you can use docker-machine to provision a new VM on your local system capable of running your docker containers. Then, when you finally go to run this on DigitalOcean, you can use docker-machine to create a DigitalOcean droplet for you. Here's some docs on that: https://docs.docker.com/machine/get-started-cloud/
To fire off several apps in parallel that all depend on each other, you can use docker-compose: https://docs.docker.com/compose/
Hope that helps.
hey enim, great question.
In the simplest of terms, you (or any other codecademy user, learning on that course) are getting a computer that is only accessible via the browser + codecademy website. It is yours, you can do most things on it you can on your normal computer (but you can only access the command line). We obviously prohibit a lot of things and try to secure it as much as possible. Under the hood everything runs on a physical machine but that machine is separated into logical different parts, each user gets a part, each parts acts as a computer (from the user's perspective). So as a side note, if you DO screw anything up it will only break the lesson (the lessons depend on the state of the machine) and only you will be affected. Eventually you will get a new machine and the lesson will work again.
Here are some technologies to explore if you are interested further: LXC - https://en.wikipedia.org/wiki/LXC Docker - https://www.docker.com/ OpenVZ Vagrant Xen
etc.
Rather than using a whole virtual machine to run a service, you can set up a pool of virtual machines and then deploy the services across them. There could be multiple services running on a given VM, and Container Engine (Kubernetes http://kubernetes.io/ is the open source version if you're curious) will manage what apps run on what VMs.
Docker is the most common container format https://www.docker.com/
This research paper describes Borg, the internal Google system that Kubernetes and Container engine are loosely based on http://research.google.com/pubs/pub43438.html
So I made this a few days ago just to get comfortable with Docker, learning the ropes etc., and it turned out to be pretty cool - thinking to myself: why not share it, maybe someone can use it or even contribute improvements of their own.
For those that have no clue what this is about: Docker is basically an application (and a framework) to quickly create and run virtual machines (containers) with usually only one specific purpose. This Dockerfile can be used to create a container for the purpose of compiling and running the NyanCoin daemon just by typing two commands.
There are thousands of pre-made docker containers, from database servers and webservers to complete suites of bulletin boards, helpdesk/troubleshooting portals or just plain virtual linux instances - all of them ready to go with just a few keystrokes. And NyanCoind is now one of them. :3
I wish these articles would just start off with a link to whatever product they're discussing.
For others wondering like me, docker is a app packaging infrastructure, their promise is that you make a package, and that is sufficient to ensure interoperability anywhere. Seems nice for intermediate level developers that don't really want to bother with environment setup, though I'm not sure if I buy their 7x figure.
As an example of Shiny, here is an app I built related to kidney metabolism:
http://sanderlab.org/kidneyMetabProject/
the Shiny source code is here (under /inst/shinyApp):
https://bitbucket.org/cbio_mskcc/kidney_metab_project
A couple of notes, 1) it was built as a R package with app and data to allow users to install and run it locally (call runShinyApp() to run locally) and 2) there is also code to run it as a Docker container; done out of concern that server-level changes or other apps could interfere with the function of this app, if multiple people are building apps and updating software (do not worry about this if you are starting out).
Vagrant is basically a tool which creates a VM from an image and runs a bunch of (user-defined) scripts to configure it. This sounds exactly like something you want. You can tell vagrant to install node on the VM and then run the scripts you already have.
Vagrant uses a configuration file (ruby script) called a Vagrantfile to determine how to configure a VM, which you can distribute through git.
A VM may seem heavy weight but running a minimal Linux distro is barely noticeable on modern hardware. You can mount directories from the host file system, meaning you can develop on the host system as you would without the VM. With something like grunt watch you wouldn't even need to interact with the VM directly.
Another, similar, alternative is Docker, but it's easiest to run on a Linux host.
One piece of advice: package your apps: either .deb., .rpm, or docker. It will save you a lot of pain and make your deployments more predictable.
We use docker and docker-compose to deploy very minimal images, and allow developers to stand up an instance of our entire system on their machine that will function exactly like our production servers. This isn't python-specific, but it is extremely useful.
I've been experimenting with Docker a lot. We're trying to come up with a dev-to-prod pipeline using containers. The goal is a little different from someone who wants to sit down and start hacking on a Magento extension, throw it on GitHub and work on something else. While you can pretty much do that with my Magento-oriented php stack Docker images, it's not easier than Vagrant in that respect. On the other hand we now have these complete images of fully-configured Magento instances with specific snapshots of the database and our extension. It's now really easy to reproduce defects and even do combinatoric configuration testing by swapping database containers.
You can do crazy things with Docker – we don't need ~any~ of the php toolchain on our local workstations anymore. PHPUnit, MD, LOC, even Jenkins are all containerized. We can switch the entire toolchain by using a different image tag.
LXC are Linux Containers. Basically, "VMs" that don't emulate the hardware. In technical details, it's chroot on steroids, because processes and networking are separated from the host.
You might have heard of docker. Docker is based on linux containers.
This technology is getting a lot of traction since ~2 years, because it allows people to create isolated environments very quickly, very cheaply. Fedora 21, for example, will have each application run in a different container (iirc). Deploying containers on AWS lets you build multi-tier architectures for cheap, etc etc. Many applications.
I personally use them as VMs for my projects (each project gets a VM). And lxc-wrapper is there to help me with that. I think this is a common usage though, so I thought it was worth sharing.
I guess you'd need to restore both the files and their timings in a lot of different places (/root/.cargo, the working directory) to prevent the Cargo from git-updating the packages after a Rust rollback.
You could use https://www.docker.com/ or some other system with snapshots (BTRFS, ZFS, LVM) to do that in a systematic way.
I'm using Docker: A Dockerfile script installs a fresh Rust and tries to build the project with it. If everything builds and passes the tests then I have a new container image to send to the servers and the team. If something fails then we simply keep using the previous image until things are fixed. Inside the container you can experiment with upgrading, then if something fails you simply restart the container returning to a known good state.
It doesn't matter much. I will tell you what I tell anybody: if you have a friend that uses Linux, use whatever he uses. If not, Ubuntu or Mint are fine choices. You can use something else later if you don't like it. (I use Arch, I used Ubuntu before, Gentoo, and others)
About servers: whenever they can choose, sysadmins tend to use on the server whatever they use on their machines. This explains in part how Ubuntu became popular on servers.
(perhaps you should learn some deploying platform like Docker, so that you can run your application in your machine and deploy it to the server using the same environment, whatever the distro you actually use in your personal computer. But this can wait)
Yes, that's one of its features.
You can build a test/dev container and then when you want to move it into prod you just copy/config update the container on to your production hosts.
Docker creators disagree with you: https://www.docker.com/blog/containers-are-not-vms/
> Docker is not a virtualization technology
It creates an appearance that it is virtualized but it is not. It is the same kernel as on the host running processes in the isolation with mounted filesystem. In simple words - if you run a Debian container in CentOS host - you are not running Debian kernel, you are still running CentOS kernel with a filesystem from the Debian image. This is very important distinction not many understands. Isolation and containerization is not virtualization, and if it was called that by someone historically - it was wrong. Humanity did wrong a lot in the past and we are probably doing something wrong today. Don't hold to the past. I don't know much about pre lxc implementations, so maybe it was even warranted there. In Linux containers it is not and there's no debate about that.
You cannot run an arm/v8 image on amd64, but you should be able to build images that work on each architecture relatively easily. Check out this post on the official docker blog
thanks for all of that comment, I agree!
> https://www.docker.com/products/docker-desktop
Yes, but do note, even when you get there, it refuses to tell you the latest version number, requiring (for me at least) downloading then either starting the install to figure out what was going to be installed or right clicking, visiting properties / details
Total crap.
Docker's FAQ tells you how to install Docker CLI and Engine without Docker Desktop:
https://www.docker.com/pricing/faq
> Can I just install the Docker CLI instead of using Docker Desktop?
> If you use a Mac, you can install Docker CLI and Engine inside a virtual machine, using VirtualBox or VMware Fusion for example, which may require purchasing a license for VirtualBox or VMware Fusion. On Windows you could install and run Docker CLI and Engine inside WSL2. If you use a Linux machine you can easily use the Docker CLI and Docker Engine, See the documentation on installing Docker Engine for instructions. Docker Desktop is not yet available for Linux.
Yes, performance loss and not enough benefits in return as you say.
However I don't know exactly how windows containers manage graphics, I am not sure if you can benefit from the dedicated GPU and draw the screen properly with the container layer in between.
Take a look at this if you want to learn more about windows containers, but they are not designed for gaming or graphic apps as far as I know:
https://www.docker.com/products/windows-containers
Since 2016 there has been a possibility to run native Windows containers on the Windows kernel
https://www.docker.com/blog/build-your-first-docker-windows-server-container/
https://docs.microsoft.com/en-us/visualstudio/install/build-tools-container
I think you misunderstand how the whole thing works, so let me explain a bit:
What is a production-ready Vue app? Basically, it's just a bunch of javascript files and media, coupled with an html file to load them.
Now, if you want to deploy this app with docker, something needs to serve all those files or, as you put it, some local files won't load, because docker on its own simply does not know where to get them. So we have to make those files available.
How can we do that? We can take an nginx container, copy the files into it and let nginx serve them. We can do the same with apache container or we can let node serve the vue app with the built-in serve and instruct an external nginx on when to use that app (basically, we turn nginx into a proxy).
I'll let the blog post on docker.com explain the process of setting it all up with an example.
https://www.docker.com/blog/changing-how-updates-work-with-docker-desktop-3-3/
Its still shitty but its better then having it automatically install ig
This is a pretty complex question. There are several problems you have to solve.
- Getting the data - you'll need to just search for a source online. Maybe there's an API, or maybe you just have to download a CSV somewhere
- Storing the data - if it's an API, you could make requests everytime you need something...though that wouldn't work for this kind of animation i think. If it's a csv, well that's convenient, just save it. If you have to scrape it, then you'll want to store it in a DB.
- Retrieving from storage - pandas probably
- Displaying data - not sure about animation, but I'd recommend starting with Plotly and Dash. This is a python framework built on React. It has a learning curve and unique syntax, but it functions as a full webserver and graphing platform. I do not know if it can do animations though.
- Hosting your app - if you did all of the above and want to host this for others to view it live on the internet, you'd need to pick a hosting platform such as heroku, google, aws, digitalocean, and the list goes on endlessly. You would probably want to learn a little about docker. In my experience, that's the best way to get an app online with a hosting service for the cheapest cost. (Heroku has a 100% free version as well)
https://www.veritis.com/blog/chef-vs-puppet-vs-ansible-comparison-of-devops-management-tools/
Either your devs work for you or they don't. If they don't, fire them and hire devs who do.
> I really do wish this feature of docker got more attention and use. Maybe since Apple is moving away from x86/amd64 we will see more of it used in releases
Yes I totally agree. My feeling is that the main reason is that corporations really don't care so much as they've got all their applications on AWS / Google Cloud, which run mostly on x86/amd64. This is unfortunate for the tinkerers who like to run things locally on their raspberry pi's. If Apple's strategy sees adoption in the cloud then sure, but as long as it's desktop/laptop only I don't see much changing - people don't typically run docker containers on their laptop.
> I am not sure how feasible this is with cloud hosting the CI pipeline for many without getting expensive
To be honest with you I don't even know all the conditions behind Github CI, but I wouldn't be surprised if they gradually wind down the free plan as more people adopt it. Luckily the project I wanted to build wasn't that resource intensive.
> Could you provide a resource or more detail on the manifest idea?
I found this blogpost talking about it: https://www.docker.com/blog/multi-arch-build-and-images-the-simple-way/. They first describe the manual "hard" way using docker manifest but I couldn't get that to work at all. The easy way is the buildx way but again with no explanation on what to do if your Dockerfile needs to be modified depending on the platform.
Honestly, what I'm missing dearly in these Dockerfiles is the ability to build in easy logic. It would be convenient if there were IF, ELSEIF, ELSE even FOR etc. so the logic can be done at the top level, instead of in a weird embedded way inside a RUN command.
Not true. Windows containers exist, and is officially supported by Microsoft, allowing you to run Windows programs inside docker (more info). You just need to set Docker for Windows' runtime, which you can do in the settings.
Personally I've never used Windows containers as I'm more of a Linux oriented person, but there's support (possibly beta?) for Kubernetes as well.
End of December, WSL 2 GPU Support for Docker is in Tech Preview, so looks like it's coming. Until then, you'll probably have to test and train on your Ubuntu machine.
You should still be able to develop on your Windows machine and set the Docker client to use your Ubuntu machine as a remote and run it like that, but haven't done anything like that myself so can't really elaborate.
I'm not sure entirely what you're asking. Most OSS projects will have instructions on how to build the code, you'll need to follow those if you want to contribute. If you're thinking Python specifically and you're worried about installed libraries interfering with other projects on your dev system, you might look into Virtualenv.
If you're thinking more large-scale, many projects these days adopt Docker to virtualize and standardize how their application runs, which sandboxes out the running code from the rest of the operating system.
Does that help answer your question?
No, the base product is free. There are premium tiers as well, but you're unlikely to need them.
Installation instructions here, essentially:
curl -fsSL https://get.docker.com -o get-docker.sh sudo sh get-docker.sh
Thank you so much!
As for the Github Actions, there's a better article if you're interested -
https://www.docker.com/blog/multi-arch-build-and-images-the-simple-way/
I just checked MQTT out, and wow, I'll probably make a v2 soon
I did want to use an Alexa initially but setting it up for external prompts wasn't very clear. Alexa's documentation is excellent though, might try that again actually.
As a stepping stone, I would probably dabble in topics such as Hyper-V, VMWare, Docker, Kubernetes and similar software packages that allow you to run virtualised workloads on a machine. This will allow you to begin to learn the basic concepts and ideas surrounding virtualisation, and what it actually means to run 'virtualised' applications.
Once a solid grasp of these concepts is learnt, you can then begin to dabble in actually creating a hypervisor driver - something, that in most instances, is extremely difficult, as the connection to the system is at a very low (kernel) level.
Perhaps also have a look at some documentation concerning the above topics. It will most definitely prove useful in learning and (eventually) creating your own hypervisor:
You'll also run into issues if your workflow uses any sort of virtualization at all, not just running Windows. For example, Docker Desktop will not currently work correctly on M1 Macs. They've said they're working on it, but it's still a WIP. Given though this is very much a developer centric issue, so keep that in mind.
For your average layperson, I've been using my M1 for a few days now and I've not run into any issues. The only minor issue I had was the Steam app being really sluggish, but that's fixed by turning off smooth scrolling and GPU acceleration.
I wouldn't recommend it if you have never dabbled with Linux and command line though. It's very daunting to begin with.
I would say install Plex on windows first then go from there.
Wrong. The limit applies to the user (or in case of anonymous download, the IP) who downloads the image, not who owns or pushed the image. To increase the limit, the downloading user needs to log in and/or have a higher tier account.
> Rate limits for Docker image pulls are based on the account type of the user requesting the image - not the account type of the image’s owner.
Why not just use Docker Desktop? It hides all of that from you and makes it look like Docker is running natively on your Mac or Windows computer (but it is using a Linux VM under the covers which you never see and don't need to be concerned with).
Poor article:
- DockerHub rate limiting is being brought in incrementally
- Amazon already have an alternative for AWS customers - ECR. Their announcement is about an upcoming public anonymous consumption docker registry
I stopped reading...
Latest blog post from Docker confirms they're working on it, but looks like there will be quite a lot of hurdles to clear before you'll be looking at a native ARM Docker daemon running x86 (less optimal) or ARM images: https://www.docker.com/blog/apple-silicon-m1-chips-and-docker/