I have written a daemon is MAC OS 10.8. I copied the Unix executable file to startup items. I have created a.plist file which has Label,KeepAlive flag set to YES and progrrammArguments array's. With DAEMON Tools for Mac you can create ISO and MDS image files from original discs inserted in physical CD/DVD/HD DVD/Blu-ray drives. Or use images you have created earlier with other program. DAEMON Tools products work with variety of image types. Creates.iso,.mds/.mdf and.mdx images images; Create up to 4 DT, SCSI or HDD.
If you are developing daemons to run on OS X, it is highly recommended that you design your daemons to be
launchd
compliant. Using launchd
provides better performance and flexibility for daemons. It also improves the ability of administrators to manage the daemons running on a given system.If you are running per-user background processes for OS X,
launchd
is also the preferred way to start these processes. These per-user processes are referred to as user agents. A user agent is essentially identical to a daemon, but is specific to a given logged-in user and executes only while that user is logged in.Unless otherwise noted, for the purposes of this chapter, the terms “daemon” and “agent” can be used interchangeably. Thus, the term “daemon” is used generically in this section to encompass both system-level daemons and user agents except where otherwise noted.
There are four ways to launch daemons using
launchd
. The preferred method is on-demand launching, but launchd
can launch daemons that run continuously, and can replace inetd
for launching inetd
-style daemons. In addition, launchd
can start jobs at timed intervals.Although
launchd
supports non-launch-on-demand daemons, this use is not recommended. The launchd
daemon was designed to remove the need for dependency ordering among daemons. If you do not make your daemon be launched on demand, you will have to handle these dependencies in another way, such as by using the legacy startup item mechanism.Launching Custom Daemons Using launchd
With the introduction of
launchd
in OS X v10.4, an effort was made to improve the steps needed to launch and maintain daemons. What launchd
provides is a harness for launching your daemon as needed. To client programs, the port representing your daemon’s service is always available and ready to handle requests. In reality, the daemon may or may not be running. When a client sends a request to the port, launchd
may have to launch the daemon so that it can handle the request. Once launched, the daemon can continue running or shut itself down to free up the memory and resources it holds. If a daemon shuts itself down, launchd
once again relaunches it as needed to process requests.In addition to the launch-on-demand feature,
launchd
provides the following benefits to daemon developers:- Simplifies the process of making a daemon by handling many of the standard housekeeping chores normally associated with launching a daemon.
- Provides system administrators with a central place to manage daemons on the system.
- Supports
inetd
-style daemons. - Eliminates the primary reason for running daemons as root. Because
launchd
runs as root, it can create low-numbered TCP/IP listen sockets and hand them off to the daemon. - Simplifies error handling and dependency management for inter-daemon communication. Because daemons launch on demand, communication requests do not fail if the daemon is not launched. They are simply delayed until the daemon can launch and process them.
The launchd Startup Process
After the system is booted and the kernel is running,
launchd
is run to finish the system initialization. As part of that initialization, it goes through the following steps: - It loads the parameters for each launch-on-demand system-level daemon from the property list files found in
/System/Library/LaunchDaemons/
and/Library/LaunchDaemons/
. - It registers the sockets and file descriptors requested by those daemons.
- It launches any daemons that requested to be running all the time.
- As requests for a particular service arrive, it launches the corresponding daemon and passes the request to it.
- When the system shuts down, it sends a
SIGTERM
signal to all of the daemons that it started.
The process for per-user agents is similar. When a user logs in, a per-user
launchd
is started. It does the following:- It loads the parameters for each launch-on-demand user agent from the property list files found in
/System/Library/LaunchAgents
,/Library/LaunchAgents
, and the user’s individualLibrary/LaunchAgents
directory. - It registers the sockets and file descriptors requested by those user agents.
- It launches any user agents that requested to be running all the time.
- As requests for a particular service arrive, it launches the corresponding user agent and passes the request to it.
- When the user logs out, it sends a
SIGTERM
signal to all of the user agents that it started.
Because
launchd
registers the sockets and file descriptors used by all daemons before it launches any of them, daemons can be launched in any order. If a request comes in for a daemon that is not yet running, the requesting process is suspended until the target daemon finishes launching and responds.If a daemon does not receive any requests over a specific period of time, it can choose to shut itself down and release the resources it holds. When this happens,
launchd
monitors the shutdown and makes a note to launch the daemon again when future requests arrive. Important: If your daemon shuts down too quickly after being launched,
launchd
may think it has crashed. Daemons that continue this behavior may be suspended and not launched again when future requests arrive. To avoid this behavior, do not shut down for at least 10 seconds after launch. Creating a launchd Property List File
To run under
launchd
, you must provide a configuration property list file for your daemon. This file contains information about your daemon, including the list of sockets or file descriptors it uses to process requests. Specifying this information in a property list file lets launchd
register the corresponding file descriptors and launch your daemon only after a request arrives for your daemon’s services. Table 5-1 lists the required and recommended keys for all daemons.The property list file is structured the same for both daemons and agents. You indicate whether it describes a daemon or agent by the directory you place it in. Property list files describing daemons are installed in
/Library/LaunchDaemons
, and those describing agents are installed in /Library/LaunchAgents
or in the LaunchAgents
subdirectory of an individual user’s Library
directory. (The appropriate location for executables that you launch from your job is /usr/local/libexec
.)Key | Description |
---|---|
Label | Contains a unique string that identifies your daemon to launchd . (required) |
ProgramArguments | Contains the arguments used to launch your daemon. (required) |
inetdCompatibility | Indicates that your daemon requires a separate instance per incoming connection. This causes launchd to behave like inetd , passing each daemon a single socket that is already connected to the incoming client. (required if your daemon was designed to be launched by inetd ; otherwise, must not be included) |
KeepAlive | This key specifies whether your daemon launches on-demand or must always be running. It is recommended that you design your daemon to be launched on-demand. |
For more information: For a complete listing of the keys, see the
launchd.plist
manual page.For sample configuration property lists, look at the files in
/System/Library/LaunchDaemons/
. These files are used to configure many daemons that run on OS X.Writing a “Hello World!” launchd Job
The following simple example launches a daemon named
hello
, passing world
as a single argument, and instructs launchd to keep the job running:In this example, there are three keys in the top level dictionary. The first is
Label
, which uniquely identifies the job. when. The second is ProgramArguments
which has a value of an array of strings which represent the tokenized arguments and the program to run. The third and final key is KeepAlive
which indicates that this job needs to be running at all times, rather than the default launch-on-demand behavior, so launchd should always try to keep this job running.Listening on Sockets
You can also include other keys in your configuration property list file. For example, if your daemon monitors a well-known port (one of the ports listed in
/etc/services
), add a Sockets
entry as follows:The string for
SockServiceName
typically comes from the leftmost column in /etc/services
. The SockType
is one of dgram
(UDP) or stream
(TCP/IP). If you need to pass a port number that is not listed in the well-known ports list, the format is the same, except the string contains a number instead of a name. For example:Debugging launchd Jobs
There are some options that are useful for debugging your launchd job.
The following example enables core dumps, sets standard out and error to go to a log file, and instructs launchd to temporarily increase the debug level of its logging while acting on behalf of your job (remember to adjust your syslog.conf accordingly):
Running a Job Periodically
The following example creates a job that is run every five minutes (300 seconds):
Alternately, you can specify a calendar-based interval. The following example starts the job on the 7th day of every month at 13:45 (1:45 pm). Like the Unix cron subsystem, any missing key of the
StartCalendarInterval
dictionary is treated as a wildcard—in this case, the month is omitted, so the job is run every month.Monitoring a Directory
The following example starts the job whenever any of the paths being watched have changed:
An additional file system trigger is the notion of a queue directory. The launchd daemon starts your job whenever the given directories are non-empty, and it keeps your job running as long as those directories are not empty:
Emulating inetd
The launchd daemon emulates the older
inetd
-style daemon semantics if you provide the inetdCompatibility
key:Behavior for Processes Managed by launchd
Processes that are managed by
launchd
must follow certain requirements so that they interact properly with launchd
. This includes launch daemons and launch agents.Required Behaviors
To support
launchd
, you must obey the following guidelines when writing your daemon code:- You must provide a property list with some basic launch-on-demand criteria for your daemon. See Creating a launchd Property List File.
- You must not daemonize your process. This includes calling the
daemon
function, callingfork
followed byexec
, or callingfork
followed byexit
. If you do,launchd
thinks your process has died. Depending on your property list key settings,launchd
will either keep trying to relaunch your process until it gives up (with a “respawning too fast” error message) or will be unable to restart it if it really does die. - Daemons and agents that are installed globally must be owned by the root user. Agents installed for the current user must be owned by that user. All daemons and agents must not be group writable or world writable. (That is, they must have file mode set to
600
or400
.)
Recommended Behaviors
To support
launchd
, it is recommended that you obey the following guidelines when writing your daemon code:- Wait until your daemon is fully initialized before attempting to process requests. Your daemon should always provide a reasonable response (rather than an error) when processing requests.
- Register the sockets and file descriptors used by your daemon in your
launchd
configuration property list file. - If your daemon advertises a socket, check in with
launchd
as part of your daemon initialization. For an example implementation of the check-in process, see SampleD. - During check-in, get the launch dictionary from
launchd
, extract and store its contents, and then discard the dictionary. Accessing the data structure used for the dictionary is very slow, so storing the whole dictionary locally and accessing it frequently could hurt performance. - Provide a handler to catch the
SIGTERM
signal.
In addition to the preceding list, the following is a list of things it is recommended you avoid in your code:
- Do not set the user or group ID for your daemon. Include the
UserName
,UID
,GroupName
, orGID
keys in your daemon’s configuration property list instead. - Do not set the working directory. Include the
WorkingDirectory
key in your daemon’s configuration property list instead. - Do not call
chroot
to change the root directory. Include theRootDirectory
key in your daemon’s configuration property list instead. - Do not call
setsid
to create a new session. - Do not close any stray file descriptors.
- Do not change
stdio
to point to/dev/null
. Include theStandardOutPath
orStandardErrorPath
keys in your daemon’s configuration property list file instead. - Do not set up resource limits with
setrusage
. - Do not set the daemon priority with
setpriority
Although many of the preceding behaviors may be standard tasks for daemons to perform, they are not recommended when running under
launchd
. The reason is that launchd
configures the operating environment for the daemons that it manages. Changing this environment could interfere with the normal operation of your daemon.Deciding When to Shut Down
If you do not expect your daemon to handle many requests, you might want to shut it down after a predetermined amount of idle time, rather than continue running. Although a well-written daemon does not consume any CPU resources when idle, it still consumes memory and could be paged out during periods of intense memory use.
The timing of when to shut down is different for each daemon and depends on several factors, including:
- The number and frequency of requests it receives
- The time it takes to launch the daemon
- The time it takes to shut down the daemon
- The need to retain state information
If your daemon does not receive frequent requests and can be launched and shut down quickly, you might prefer to shut it down rather than wait for it to be paged out to disk. Paging memory to disk, and subsequently reading it back, incurs two disk operations. If you do not need the data stored in memory, your daemon can shut down and avoid the step of writing memory to disk.
Special Dependencies
While
launchd
takes care of dependencies between daemons, in some cases, your daemon may depend on other system functionality that cannot be addressed in this manner. This section describes many of these special cases and how to handle them.Network Availability
If your daemon depends on the network being available, this cannot be handled with dependencies because network interfaces can come and go at any time in OS X. To solve this problem, you should use the network reachability functionality or the dynamic store functionality in the System Configuration framework. This is documented in System Configuration Programming Guidelines and System Configuration Framework Reference. For more information about network reachability, see Determining Reachability and Getting Connected in System Configuration Programming Guidelines.
Disk or Server Availability
If your daemon depends on the availability of a mounted volume (whether local or remote), you can determine the status of that volume using the Disk Arbitration framework. This is documented in Disk Arbitration Framework Reference.
Non-launchd Daemons
If your daemon has a dependency on a non-
launchd
daemon, you must take additional care to ensure that your daemon works correctly if that non-launchd
daemon has not started when your daemon is started. The best way to do this is to include a loop at start time that checks to see if the non-launchd
daemon is running, and if not, sleeps for several seconds before checking again.Be sure to set up handlers for
SIGTERM
prior to this loop to ensure that you are able to properly shut down if the daemon you rely on never becomes available.User Logins
In general, a daemon should not care whether a user is logged in, and user agents should be used to provide per-user functionality. However, in some cases, this may be useful.
To determine what user is logged in at the console, you can use the System Configuration framework, as described in Technical Q&A QA1133.
Kernel Extensions
If your daemon requires that a certain kernel extension be loaded prior to executing, you have two options: load it yourself, or wait for it to be loaded.
The daemon may manually request that an extension be loaded. To do this, run
kextload
with the appropriate arguments using exec
or variants thereof. I/O Kit kernel extensions should not be loaded with kextload
; the I/O Kit will load them automatically when they are needed.Note: The
kextload
executable must be run as root in order to load extensions into the kernel. For security reasons, it is not a setuid executable. This means that your daemon must either be running as the root user or must include a helper binary that is setuid root in order to use kextload
to load a kernel extension.Alternatively, our daemon may wait for a kernel service to be available. To do this, you should first register for service change notification. This is further documented in I/O Kit Framework Reference.
After registering for these notifications, you should check to see if the service is already available. By doing this after registering for notifications, you avoid waiting forever if the service becomes available between checking for availability and registering for the notification.
Note: In order for your kernel extension to be detected in a useful way, it must publish a node in the I/O registry to advertise the availability of its service. For I/O Kit drivers, this is usually handled by the I/O Kit family.
For other kernel extensions, you must explicitly register the service by publishing a nub, which must be an instance of
IOService
.For more information about I/O Kit services and matching, see IOKit Fundamentals, I/O Kit Framework Reference (user space reference), and Kernel Framework Reference (kernel space reference).
For More Information
The manual pages for
launchd
and launchd.plist
are the two best sources for information about launchd
.In addition, you can find a source daemon accompanying the
launchd
source code (available from http://www.macosforge.org/). This daemon is also provided from the Mac Developer Library as the SampleD sample code project.The Daemons and Agents technical note provides additional information about how
launchd
daemons and agents work under the hood.Finally, many Apple-provided daemons support
launchd
. Their property list files can be found in /System/Library/LaunchDaemons
. Some of these daemons are also available as open source from http://www.opensource.apple.com/ or http://www.macosforge.org/. Copyright © 2003, 2016 Apple Inc. All Rights Reserved. Terms of Use | Privacy Policy | Updated: 2016-09-13
Estimated reading time: 16 minutes
Welcome to Docker Desktop! The Docker Desktop for Mac user manual provides information on how to configure and manage your Docker Desktop settings.
For information about Docker Desktop download, system requirements, and installation instructions, see Install Docker Desktop.
Note
This page contains information about the Docker Desktop Stable release. For information about features available in Edge releases, see the Edge release notes.
Preferences
The Docker Preferences menu allows you to configure your Docker settings such as installation, updates, version channels, Docker Hub login,and more.
Choose the Docker menu > Preferences from themenu bar and configure the runtime options described below.
General
On the General tab, you can configure when to start and update Docker:
![Mac Mac](/uploads/1/1/7/7/117768160/206633856.jpg)
- Start Docker Desktop when you log in: Automatically starts Docker Desktop when you open your session.
- Automatically check for updates: By default, Docker Desktop automatically checks for updates and notifies you when an update is available. You can manually check for updates anytime by choosing Check for Updates from the main Docker menu.
- Include VM in Time Machine backups: Select this option to back up the Docker Desktop virtual machine. This option is disabled by default.
- Securely store Docker logins in macOS keychain: Docker Desktop stores your Docker login credentials in macOS keychain by default.
- Send usage statistics: Docker Desktop sends diagnostics, crash reports, and usage data. This information helps Docker improve and troubleshoot the application. Clear the check box to opt out.Click Switch to the Edge version to learn more about Docker Desktop Edge releases.
Resources
The Resources tab allows you to configure CPU, memory, disk, proxies, network, and other resources.
Advanced
On the Advanced tab, you can limit resources available to Docker.
Advanced settings are:
CPUs: By default, Docker Desktop is set to use half the number of processorsavailable on the host machine. To increase processing power, set this to ahigher number; to decrease, lower the number.
Memory: By default, Docker Desktop is set to use
2
GB runtime memory,allocated from the total available memory on your Mac. To increase the RAM, set this to a higher number. To decrease it, lower the number.Swap: Configure swap file size as needed. The default is 1 GB.
Disk image size: Specify the size of the disk image.
Google Software Update Daemon Mac
Disk image location: Specify the location of the Linux volume where containers and images are stored.
You can also move the disk image to a different location. If you attempt to move a disk image to a location that already has one, you get a prompt asking if you want to use the existing image or replace it.
File sharing
Use File sharing to allow local directories on the Mac to be shared with Linux containers.This is especially useful forediting source code in an IDE on the host while running and testing the code in a container.By default the
/Users
, /Volume
, /private
, /tmp
and /var/folders
directory are shared. If your project is outside this directory then it must be addedto the list. Otherwise you may get Mounts denied
or cannot start service
errors at runtime.File share settings are:
- Add a Directory: Click
+
and navigate to the directory you want to add. - Apply & Restart makes the directory available to containers using Docker’sbind mount (
-v
) feature.
Tips on shared folders, permissions, and volume mounts
- Shared folders are designed to allow application code to be edited on the host while being executed in containers. For non-code items such as cache directories or databases, the performance will be much better if they are stored in the Linux VM, using a data volume (named volume) or data container.
- By default, Mac file systems are case-insensitive while Linux is case-sensitive. On Linux, it is possible to create 2 separate files:
test
andTest
, while on Mac these filenames would actually refer to the same underlying file. This can lead to problems where an app works correctly on a Mac (where the file contents are shared) but fails when run in Linux in production (where the file contents are distinct). To avoid this, Docker Desktop insists that all shared files are accessed as their original case. Therefore, if a file is created calledtest
, it must be opened astest
. Attempts to openTest
will fail with the errorNo such file or directory
. Similarly, once a file calledtest
is created, attempts to create a second file calledTest
will fail. For more information, see Volume mounting requires file sharing for any project directories outside of/Users
.)
Proxies
Docker Desktop detects HTTP/HTTPS Proxy Settings from macOS and automaticallypropagates these to Docker. For example, if you set yourproxy settings to
http://proxy.example.com
, Docker uses this proxy whenpulling containers.Your proxy settings, however, will not be propagated into the containers you start.If you wish to set the proxy settings for your containers, you need to defineenvironment variables for them, just like you would do on Linux, for example:
For more information on setting environment variables for running containers,see Set environment variables.
Network
You can configure Docker Desktop networking to work on a virtual private network (VPN). Specify a network address translation (NAT) prefix and subnet mask to enable Internet connectivity.
Docker Engine
The Docker Engine page allows you to configure the Docker daemon to determine how your containers run.
Type a JSON configuration file in the box to configure the daemon settings. For a full list of options, see the Docker Enginedockerd commandline reference.
Click Apply & Restart to save your settings and restart Docker Desktop.
Command Line
On the Command Line page, you can specify whether or not to enable experimental features.
Experimental features provide early access to future product functionality.These features are intended for testing and feedback only as they may changebetween releases without warning or can be removed entirely from a futurerelease. Experimental features must not be used in production environments.Docker does not offer support for experimental features.
To enable experimental features in the Docker CLI, edit the
config.json
file and set experimental
to enabled.To enable experimental features from the Docker Desktop menu, clickSettings (Preferences on macOS) > Command Line and then turn onthe Enable experimental features toggle. Click Apply & Restart.
For a list of current experimental features in the Docker CLI, see Docker CLI Experimental features.
On both Docker Desktop Edge and Stable releases, you can toggle the experimental features on and off. If you toggle the experimental features off, Docker Desktop uses the current generally available release of Docker Engine.
You can see whether you are running experimental mode at the command line. If
Experimental
is true
, then Docker is running in experimental mode, as shownhere. (If false
, Experimental mode is off.)Kubernetes
Docker Desktop includes a standalone Kubernetes server that runs on your Mac, sothat you can test deploying your Docker workloads on Kubernetes.
The Kubernetes client command,
kubectl
, is included and configured to connectto the local Kubernetes server. If you have kubectl
already installed andpointing to some other environment, such as minikube
or a GKE cluster, be sureto change context so that kubectl
is pointing to docker-desktop
:If you installed
kubectl
with Homebrew, or by some other method, andexperience conflicts, remove /usr/local/bin/kubectl
.- To enable Kubernetes support and install a standalone instance of Kubernetesrunning as a Docker container, select Enable Kubernetes. To set Kubernetes as thedefault orchestrator, select Deploy Docker Stacks to Kubernetes by default.Click Apply & Restart to save the settings. This instantiates images required to run the Kubernetes server as containers, and installs the
/usr/local/bin/kubectl
command on your Mac.When Kubernetes is enabled and running, an additional status bar item displaysat the bottom right of the Docker Desktop Settings dialog.The status of Kubernetes shows in the Docker menu and the context points todocker-desktop
. - By default, Kubernetes containers are hidden from commands like
dockerservice ls
, because managing them manually is not supported. To make themvisible, select Show system containers (advanced) and click Apply andRestart. Most users do not need this option. - To disable Kubernetes support at any time, clear the Enable Kubernetes check box. TheKubernetes containers are stopped and removed, and the
/usr/local/bin/kubectl
command is removed.For more about using the Kubernetes integration with Docker Desktop, seeDeploy on Kubernetes.
Reset
Reset and Restart options
On Docker Desktop Mac, the Restart Docker Desktop, Reset to factory defaults, and other reset options are available from the Troubleshoot menu.
For information about the reset options, see Logs and Troubleshooting.
Dashboard
The Docker Desktop Dashboard enables you to interact with containers and applications and manage the lifecycle of your applications directly from your machine. The Dashboard UI shows all running, stopped, and started containers with their state. It provides an intuitive interface to perform common actions to inspect and manage containers and existing Docker Compose applications. For more information, see Docker Desktop Dashboard.
Add TLS certificates
What Is Alert Daemon For Mac
You can add trusted Certificate Authorities (CAs) (used to verify registryserver certificates) and client certificates (used to authenticate toregistries) to your Docker daemon.
Add custom CA certificates (server side)
All trusted CAs (root or intermediate) are supported. Docker Desktop creates acertificate bundle of all user-trusted CAs based on the Mac Keychain, andappends it to Moby trusted certificates. So if an enterprise SSL certificate istrusted by the user on the host, it is trusted by Docker Desktop.
To manually add a custom, self-signed certificate, start by adding thecertificate to the macOS keychain, which is picked up by Docker Desktop. Here isan example:
Or, if you prefer to add the certificate to your own local keychain only (ratherthan for all users), run this command instead:
See also, Directory structures forcertificates.
Note: You need to restart Docker Desktop after making any changes to thekeychain or to the
~/.docker/certs.d
directory in order for the changes totake effect.For a complete explanation of how to do this, see the blog post AddingSelf-signed Registry Certs to Docker & Docker Desktop forMac.
Add client certificates
You can put your client certificates in
~/.docker/certs.d/<MyRegistry>:<Port>/client.cert
and~/.docker/certs.d/<MyRegistry>:<Port>/client.key
.When the Docker Desktop application starts, it copies the
~/.docker/certs.d
folder on your Mac to the /etc/docker/certs.d
directory on Moby (the DockerDesktop xhyve
virtual machine).- You need to restart Docker Desktop after making any changes to the keychainor to the
~/.docker/certs.d
directory in order for the changes to takeeffect. - The registry cannot be listed as an insecure registry (see DockerEngine. Docker Desktop ignores certificates listedunder insecure registries, and does not send client certificates. Commandslike
docker run
that attempt to pull from the registry produce errormessages on the command line, as well as on the registry.
Directory structures for certificates
If you have this directory structure, you do not need to manually add the CAcertificate to your Mac OS system login:
The following further illustrates and explains a configuration with customcertificates:
Daemon Machina Switch
You can also have this directory structure, as long as the CA certificate isalso in your keychain.
To learn more about how to install a CA root certificate for the registry andhow to set the client TLS certificate for verification, seeVerify repository client with certificatesin the Docker Engine topics.
Install shell completion
Docker Desktop comes with scripts to enable completion for the
docker
and docker-compose
commands. The completion scripts may befound inside Docker.app
, in the Contents/Resources/etc/
directory and can beinstalled both in Bash and Zsh.Bash
Bash has built-in support forcompletion To activate completion for Docker commands, these files need to becopied or symlinked to your
bash_completion.d/
directory. For example, if youinstalled bash via Homebrew:Add the following to your
~/.bash_profile
:OR
Zsh
In Zsh, the completionsystemtakes care of things. To activate completion for Docker commands,these files need to be copied or symlinked to your Zsh
site-functions/
directory. For example, if you installed Zsh via Homebrew:Fish-Shell
Fish-shell also supports tab completion completionsystem. To activate completion for Docker commands,these files need to be copied or symlinked to your Fish-shell
completions/
directory.Create the
completions
directory:Now add fish completions from docker.
![Download Download](/uploads/1/1/7/7/117768160/890759312.png)
Give feedback and get help
To get help from the community, review current user topics, join or start adiscussion, log on to our Docker Desktop for Macforum.
To report bugs or problems, log on to Docker Desktop for Mac issues onGitHub,where you can review community reported issues, and file new ones. SeeLogs and Troubleshooting for more details.
Daemon For Mac
For information about providing feedback on the documentation or update it yourself, see Contribute to documentation.
Docker Hub
Select Sign in /Create Docker ID from the Docker Desktop menu to access your Docker Hub account. Once logged in, you can access your Docker Hub repositories and organizations directly from the Docker Desktop menu.
For more information, refer to the following Docker Hub topics:
Two-factor authentication
Docker Desktop enables you to sign into Docker Hub using two-factor authentication. Two-factor authentication provides an extra layer of security when accessing your Docker Hub account.
You must enable two-factor authentication in Docker Hub before signing into your Docker Hub account through Docker Desktop. For instructions, see Enable two-factor authentication for Docker Hub.
After you have enabled two-factor authentication:
- Go to the Docker Desktop menu and then select Sign in / Create Docker ID.
- Enter your Docker ID and password and click Sign in.
- After you have successfully signed in, Docker Desktop prompts you to enter the authentication code. Enter the six-digit code from your phone and then click Verify.
After you have successfully authenticated, you can access your organizations and repositories directly from the Docker Desktop menu.
Where to go next
- Try out the walkthrough at Get Started.
- Dig in deeper with Docker Labs examplewalkthroughs and source code.
- For a summary of Docker command line interface (CLI) commands, seeDocker CLI Reference Guide.
- Check out the blog post, What’s New in Docker 17.06 Community Edition(CE).