chrony vs. systemd-timesyncd – What are the differences and use cases as NTP clients?ntpd vs....

Should I choose Itemized or Standard deduction?

What is the wife of a henpecked husband called?

How to count words in a line

I encountered my boss during an on-site interview at another company. Should I bring it up when seeing him next time?

Non-Italian European mafias in USA?

How to avoid being sexist when trying to employ someone to function in a very sexist environment?

It took me a lot of time to make this, pls like. (YouTube Comments #1)

Make me a metasequence

Most significant research articles for practical investors with research perspectives

Can I become debt free or should I file for bankruptcy? How do I manage my debt and finances?

I am on the US no-fly list. What can I do in order to be allowed on flights which go through US airspace?

What can I substitute for soda pop in a sweet pork recipe?

How can I be pwned if I'm not registered on that site?

Casually inserting sexuality

Can you 'upgrade' leather armor to studded leather armor without purchasing the new armor directly?

Is there any relevance to Thor getting his hair cut other than comedic value?

Has the Isbell–Freyd criterion ever been used to check that a category is concretisable?

What is the difference between ashamed and shamed?

As a new poet, where can I find help from a professional to judge my work?

CBP Reminds Travelers to Allow 72 Hours for ESTA. Why?

Understanding Kramnik's play in game 1 of Candidates 2018

Sometimes a banana is just a banana

Auto Insert date into Notepad

How to properly claim credit for peer review?



chrony vs. systemd-timesyncd – What are the differences and use cases as NTP clients?


ntpd vs. systemd-timesyncd - How to achieve reliable NTP syncing?What are the pros/cons of Upstart and systemd?What are possible reasons for erratic NTP synchronistation?What is the recommended way to synchronize time using NTP?Automatically update hwclock at bootCentOS 7.2 Minimal Time synchronization timedated and/or ntpd/chronyntpd vs. systemd-timesyncd - How to achieve reliable NTP syncing?NTP Servers not Sync with other machinesNTP not syncing time even with `tinker panic 0` in /etc/ntp.conf in Centos 7.3 -Resuming VM from paused statesystemd: start openvpn.service after time has syncedDifference between suspend by echo “mem” > /sys/power/state and by suspend in XFCE?













3















Somehow but not quite building upon the older question "ntpd vs. systemd-timesyncd - How to achieve reliable NTP syncing?", I'd like to ask about the differences between chrony and systemd-timesyncd in terms of an NTP client.



I know that systemd-timesyncd is a more or less minimal ntp client implementation whereas chrony is a full fledged NTP daemon solution that happens to include an NTP client.



The ubuntu Bionic Beaver release notes state the following:




For simple time sync needs the base system already comes with systemd-timesyncd. Chrony is only needed to act as a time server or if you want the advertised more accurate and efficient syncing.




I like the idea of using a minimal preinstalled tool to do the job and I am pretty sure systemd-timesyncd will do the job for my use cases, still I am curious:




  • What are the real world differences between the two in terms of accuracy?

  • What are the differences in efficiency?

  • What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?










share|improve this question



























    3















    Somehow but not quite building upon the older question "ntpd vs. systemd-timesyncd - How to achieve reliable NTP syncing?", I'd like to ask about the differences between chrony and systemd-timesyncd in terms of an NTP client.



    I know that systemd-timesyncd is a more or less minimal ntp client implementation whereas chrony is a full fledged NTP daemon solution that happens to include an NTP client.



    The ubuntu Bionic Beaver release notes state the following:




    For simple time sync needs the base system already comes with systemd-timesyncd. Chrony is only needed to act as a time server or if you want the advertised more accurate and efficient syncing.




    I like the idea of using a minimal preinstalled tool to do the job and I am pretty sure systemd-timesyncd will do the job for my use cases, still I am curious:




    • What are the real world differences between the two in terms of accuracy?

    • What are the differences in efficiency?

    • What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?










    share|improve this question

























      3












      3








      3








      Somehow but not quite building upon the older question "ntpd vs. systemd-timesyncd - How to achieve reliable NTP syncing?", I'd like to ask about the differences between chrony and systemd-timesyncd in terms of an NTP client.



      I know that systemd-timesyncd is a more or less minimal ntp client implementation whereas chrony is a full fledged NTP daemon solution that happens to include an NTP client.



      The ubuntu Bionic Beaver release notes state the following:




      For simple time sync needs the base system already comes with systemd-timesyncd. Chrony is only needed to act as a time server or if you want the advertised more accurate and efficient syncing.




      I like the idea of using a minimal preinstalled tool to do the job and I am pretty sure systemd-timesyncd will do the job for my use cases, still I am curious:




      • What are the real world differences between the two in terms of accuracy?

      • What are the differences in efficiency?

      • What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?










      share|improve this question














      Somehow but not quite building upon the older question "ntpd vs. systemd-timesyncd - How to achieve reliable NTP syncing?", I'd like to ask about the differences between chrony and systemd-timesyncd in terms of an NTP client.



      I know that systemd-timesyncd is a more or less minimal ntp client implementation whereas chrony is a full fledged NTP daemon solution that happens to include an NTP client.



      The ubuntu Bionic Beaver release notes state the following:




      For simple time sync needs the base system already comes with systemd-timesyncd. Chrony is only needed to act as a time server or if you want the advertised more accurate and efficient syncing.




      I like the idea of using a minimal preinstalled tool to do the job and I am pretty sure systemd-timesyncd will do the job for my use cases, still I am curious:




      • What are the real world differences between the two in terms of accuracy?

      • What are the differences in efficiency?

      • What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?







      systemd ntp chrony






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked 1 hour ago









      wediwedi

      1163




      1163






















          3 Answers
          3






          active

          oldest

          votes


















          1














          The announcement of systemd-timesyncd in the systemd NEWS file does a good job of explaining the differences of this tool in comparison with Chrony and tools like it. (emphasis mine):




          A new "systemd-timesyncd" daemon has been added for
          synchronizing the system clock across the network. It
          implements an SNTP client. In contrast to NTP
          implementations such as chrony or the NTP reference server
          this only implements a client side, and does not bother with
          the full NTP complexity, focusing only on querying time from
          one remote server and synchronizing the local clock to
          it
          . Unless you intend to serve NTP to networked clients or
          want to connect to local hardware clocks this simple NTP
          client should be more than appropriate for most
          installations. [...]




          This setup is a common use case for most hosts in a server fleet. They will usually get synchronized from local NTP servers, which themselves get synchronized from multiple sources, possibly including hardware. systemd-timesyncd tries to provide an easy-to-use solution for that common use case.





          Trying to address your specific questions:




          What are the real world differences between the two in terms of accuracy?




          I believe you can get higher accuracy by getting synchronization data from multiple sources, which is specifically not a supported use case for systemd-timesyncd. But when you're using it to get synchronization data from central NTP servers connected to your reliable internal network, using multiple sources isn't really that relevant and you get good accuracy from a single source.




          What are the differences in efficiency?




          Getting synchronization from a single source is much simpler than getting it from multiple sources, since you don't have to make decisions about which sources are better than others and possibly combine information from multiple sources. The algorithms are much simpler and will require less CPU load for the simple case.




          What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?




          That's addressed in the quote above, but in any case these are use cases for Chrony that are not covered by systemd-timesyncd:




          • running NTP server (so that other hosts can use this host as a source for synchrnoization);

          • getting NTP synchronization information from multiple sources (which is important for hosts getting that information from public servers on the Internet); and

          • getting synchronization information from the local clock, which usually involves specialized hardware such as GPS devices which can get accurate time information from satellites.


          These use cases require Chrony or ntpd or similar.






          share|improve this answer































            1














            The full NTP client will attempt to modify the running clock's drift rate. If a client seems to be slow, it will speed it up. When successful, the clock remains more accurate between updates. Also (when running properly) all further updates are only by drift adjustment. It will not need to "jump" the clock.



            Most SNTP clients will not attempt any modification of the drift rate. It simply sets the clock when a successful update runs. If the clock run rate is fast, these updates will require setting the clock backward, meaning it is possible for a specific time to occur more than once. In most end-user cases, these jumps will be small enough they don't cause a problem. But you should be aware they are possible. They are of course more likely if connectivity is disturbed for a long period of time.



            So "accuracy" depends on the poll rate and the accuracy of the local oscillator. Some hardware is pretty good, some hardware is awful. You'd have to measure your system to see how bad it drifts between polls.






            share|improve this answer
























            • More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

              – Rui F Ribeiro
              40 mins ago



















            1














            As the other answer correctly states, chrony implements NTP and systemd-timesyncd SNTP.



            From the point of view of a time service client:



            SNTP is a much more simple protocol to implement;

            NTP allows for step-by-step increments/corrections on time. One major advantage of NTP is that it also takes on account the RTT of the answer to get a more exact time.



            From https://www.meinbergglobal.com/english/faq/faq_37.htm




            While a full featured NTP server or client reaches a very high level
            of accuracy and avoids abrupt time steps as much as possible by using
            different mathematical and statistical methods and smooth clock speed
            adjustments, SNTP can only be recommended for simple applications,
            where the requirements for accuracy and reliability are not too
            demanding. By disregarding drift values and using simplified ways of
            system clock adjustment methods (often simple time stepping), SNTP
            achieves only a low quality time synchronisation when compared with a
            full NTP implementation.



            SNTP adopts a much simpler approach. Many of the complexities of the
            NTP algorithm are removed. Rather than skewing time, many SNTP clients
            step time. This is fine for many applications where a simple
            time-stamp is required. Additionally, SNTP lacks the ability to
            monitor and filter multiple NTP servers. Often a simple round-robin
            approach is used, where if one server fails, the next one in a list is
            used




            From https://www.masterclock.com/company/masterclock-inc-blog/ntp-vs-sntp




            NTP is far more accurate and precise than SNTP, and this makes it the
            de facto winner in most enterprise applications. On the other hand,
            the simplicity of SNTP makes it more appropriate for things like IP
            cameras, DVRs and some network switches. These types of hardware lack
            the processing resources to handle more complex protocols, but as
            connected devices become increasingly powerful, that may change.



            One major weak point of SNTP is that you can't make it more accurate
            by retrieving time from multiple sources like Network Time Protocol does by default.




            One other major point I can see SNTP implementations giving more problems than NTP is in virtualisation, when you have both the hypervisor and NTP daemon trying to change the VM time. Specially with them not agreeing on time with some misconfiguration, it will cause big problems. (Whilst competent system administrators will try to disable the former, it can happen they are both active).



            P.S. Obviously systemd-timesyncd is not an alternative when not using systemd.






            share|improve this answer

























              Your Answer








              StackExchange.ready(function() {
              var channelOptions = {
              tags: "".split(" "),
              id: "106"
              };
              initTagRenderer("".split(" "), "".split(" "), channelOptions);

              StackExchange.using("externalEditor", function() {
              // Have to fire editor after snippets, if snippets enabled
              if (StackExchange.settings.snippets.snippetsEnabled) {
              StackExchange.using("snippets", function() {
              createEditor();
              });
              }
              else {
              createEditor();
              }
              });

              function createEditor() {
              StackExchange.prepareEditor({
              heartbeatType: 'answer',
              autoActivateHeartbeat: false,
              convertImagesToLinks: false,
              noModals: true,
              showLowRepImageUploadWarning: true,
              reputationToPostImages: null,
              bindNavPrevention: true,
              postfix: "",
              imageUploader: {
              brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
              contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
              allowUrls: true
              },
              onDemand: true,
              discardSelector: ".discard-answer"
              ,immediatelyShowMarkdownHelp:true
              });


              }
              });














              draft saved

              draft discarded


















              StackExchange.ready(
              function () {
              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2funix.stackexchange.com%2fquestions%2f504381%2fchrony-vs-systemd-timesyncd-what-are-the-differences-and-use-cases-as-ntp-cli%23new-answer', 'question_page');
              }
              );

              Post as a guest















              Required, but never shown

























              3 Answers
              3






              active

              oldest

              votes








              3 Answers
              3






              active

              oldest

              votes









              active

              oldest

              votes






              active

              oldest

              votes









              1














              The announcement of systemd-timesyncd in the systemd NEWS file does a good job of explaining the differences of this tool in comparison with Chrony and tools like it. (emphasis mine):




              A new "systemd-timesyncd" daemon has been added for
              synchronizing the system clock across the network. It
              implements an SNTP client. In contrast to NTP
              implementations such as chrony or the NTP reference server
              this only implements a client side, and does not bother with
              the full NTP complexity, focusing only on querying time from
              one remote server and synchronizing the local clock to
              it
              . Unless you intend to serve NTP to networked clients or
              want to connect to local hardware clocks this simple NTP
              client should be more than appropriate for most
              installations. [...]




              This setup is a common use case for most hosts in a server fleet. They will usually get synchronized from local NTP servers, which themselves get synchronized from multiple sources, possibly including hardware. systemd-timesyncd tries to provide an easy-to-use solution for that common use case.





              Trying to address your specific questions:




              What are the real world differences between the two in terms of accuracy?




              I believe you can get higher accuracy by getting synchronization data from multiple sources, which is specifically not a supported use case for systemd-timesyncd. But when you're using it to get synchronization data from central NTP servers connected to your reliable internal network, using multiple sources isn't really that relevant and you get good accuracy from a single source.




              What are the differences in efficiency?




              Getting synchronization from a single source is much simpler than getting it from multiple sources, since you don't have to make decisions about which sources are better than others and possibly combine information from multiple sources. The algorithms are much simpler and will require less CPU load for the simple case.




              What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?




              That's addressed in the quote above, but in any case these are use cases for Chrony that are not covered by systemd-timesyncd:




              • running NTP server (so that other hosts can use this host as a source for synchrnoization);

              • getting NTP synchronization information from multiple sources (which is important for hosts getting that information from public servers on the Internet); and

              • getting synchronization information from the local clock, which usually involves specialized hardware such as GPS devices which can get accurate time information from satellites.


              These use cases require Chrony or ntpd or similar.






              share|improve this answer




























                1














                The announcement of systemd-timesyncd in the systemd NEWS file does a good job of explaining the differences of this tool in comparison with Chrony and tools like it. (emphasis mine):




                A new "systemd-timesyncd" daemon has been added for
                synchronizing the system clock across the network. It
                implements an SNTP client. In contrast to NTP
                implementations such as chrony or the NTP reference server
                this only implements a client side, and does not bother with
                the full NTP complexity, focusing only on querying time from
                one remote server and synchronizing the local clock to
                it
                . Unless you intend to serve NTP to networked clients or
                want to connect to local hardware clocks this simple NTP
                client should be more than appropriate for most
                installations. [...]




                This setup is a common use case for most hosts in a server fleet. They will usually get synchronized from local NTP servers, which themselves get synchronized from multiple sources, possibly including hardware. systemd-timesyncd tries to provide an easy-to-use solution for that common use case.





                Trying to address your specific questions:




                What are the real world differences between the two in terms of accuracy?




                I believe you can get higher accuracy by getting synchronization data from multiple sources, which is specifically not a supported use case for systemd-timesyncd. But when you're using it to get synchronization data from central NTP servers connected to your reliable internal network, using multiple sources isn't really that relevant and you get good accuracy from a single source.




                What are the differences in efficiency?




                Getting synchronization from a single source is much simpler than getting it from multiple sources, since you don't have to make decisions about which sources are better than others and possibly combine information from multiple sources. The algorithms are much simpler and will require less CPU load for the simple case.




                What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?




                That's addressed in the quote above, but in any case these are use cases for Chrony that are not covered by systemd-timesyncd:




                • running NTP server (so that other hosts can use this host as a source for synchrnoization);

                • getting NTP synchronization information from multiple sources (which is important for hosts getting that information from public servers on the Internet); and

                • getting synchronization information from the local clock, which usually involves specialized hardware such as GPS devices which can get accurate time information from satellites.


                These use cases require Chrony or ntpd or similar.






                share|improve this answer


























                  1












                  1








                  1







                  The announcement of systemd-timesyncd in the systemd NEWS file does a good job of explaining the differences of this tool in comparison with Chrony and tools like it. (emphasis mine):




                  A new "systemd-timesyncd" daemon has been added for
                  synchronizing the system clock across the network. It
                  implements an SNTP client. In contrast to NTP
                  implementations such as chrony or the NTP reference server
                  this only implements a client side, and does not bother with
                  the full NTP complexity, focusing only on querying time from
                  one remote server and synchronizing the local clock to
                  it
                  . Unless you intend to serve NTP to networked clients or
                  want to connect to local hardware clocks this simple NTP
                  client should be more than appropriate for most
                  installations. [...]




                  This setup is a common use case for most hosts in a server fleet. They will usually get synchronized from local NTP servers, which themselves get synchronized from multiple sources, possibly including hardware. systemd-timesyncd tries to provide an easy-to-use solution for that common use case.





                  Trying to address your specific questions:




                  What are the real world differences between the two in terms of accuracy?




                  I believe you can get higher accuracy by getting synchronization data from multiple sources, which is specifically not a supported use case for systemd-timesyncd. But when you're using it to get synchronization data from central NTP servers connected to your reliable internal network, using multiple sources isn't really that relevant and you get good accuracy from a single source.




                  What are the differences in efficiency?




                  Getting synchronization from a single source is much simpler than getting it from multiple sources, since you don't have to make decisions about which sources are better than others and possibly combine information from multiple sources. The algorithms are much simpler and will require less CPU load for the simple case.




                  What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?




                  That's addressed in the quote above, but in any case these are use cases for Chrony that are not covered by systemd-timesyncd:




                  • running NTP server (so that other hosts can use this host as a source for synchrnoization);

                  • getting NTP synchronization information from multiple sources (which is important for hosts getting that information from public servers on the Internet); and

                  • getting synchronization information from the local clock, which usually involves specialized hardware such as GPS devices which can get accurate time information from satellites.


                  These use cases require Chrony or ntpd or similar.






                  share|improve this answer













                  The announcement of systemd-timesyncd in the systemd NEWS file does a good job of explaining the differences of this tool in comparison with Chrony and tools like it. (emphasis mine):




                  A new "systemd-timesyncd" daemon has been added for
                  synchronizing the system clock across the network. It
                  implements an SNTP client. In contrast to NTP
                  implementations such as chrony or the NTP reference server
                  this only implements a client side, and does not bother with
                  the full NTP complexity, focusing only on querying time from
                  one remote server and synchronizing the local clock to
                  it
                  . Unless you intend to serve NTP to networked clients or
                  want to connect to local hardware clocks this simple NTP
                  client should be more than appropriate for most
                  installations. [...]




                  This setup is a common use case for most hosts in a server fleet. They will usually get synchronized from local NTP servers, which themselves get synchronized from multiple sources, possibly including hardware. systemd-timesyncd tries to provide an easy-to-use solution for that common use case.





                  Trying to address your specific questions:




                  What are the real world differences between the two in terms of accuracy?




                  I believe you can get higher accuracy by getting synchronization data from multiple sources, which is specifically not a supported use case for systemd-timesyncd. But when you're using it to get synchronization data from central NTP servers connected to your reliable internal network, using multiple sources isn't really that relevant and you get good accuracy from a single source.




                  What are the differences in efficiency?




                  Getting synchronization from a single source is much simpler than getting it from multiple sources, since you don't have to make decisions about which sources are better than others and possibly combine information from multiple sources. The algorithms are much simpler and will require less CPU load for the simple case.




                  What are a "non simple" time sync needs aka the use-cases for chrony as NTP client?




                  That's addressed in the quote above, but in any case these are use cases for Chrony that are not covered by systemd-timesyncd:




                  • running NTP server (so that other hosts can use this host as a source for synchrnoization);

                  • getting NTP synchronization information from multiple sources (which is important for hosts getting that information from public servers on the Internet); and

                  • getting synchronization information from the local clock, which usually involves specialized hardware such as GPS devices which can get accurate time information from satellites.


                  These use cases require Chrony or ntpd or similar.







                  share|improve this answer












                  share|improve this answer



                  share|improve this answer










                  answered 1 hour ago









                  filbrandenfilbranden

                  10.3k21645




                  10.3k21645

























                      1














                      The full NTP client will attempt to modify the running clock's drift rate. If a client seems to be slow, it will speed it up. When successful, the clock remains more accurate between updates. Also (when running properly) all further updates are only by drift adjustment. It will not need to "jump" the clock.



                      Most SNTP clients will not attempt any modification of the drift rate. It simply sets the clock when a successful update runs. If the clock run rate is fast, these updates will require setting the clock backward, meaning it is possible for a specific time to occur more than once. In most end-user cases, these jumps will be small enough they don't cause a problem. But you should be aware they are possible. They are of course more likely if connectivity is disturbed for a long period of time.



                      So "accuracy" depends on the poll rate and the accuracy of the local oscillator. Some hardware is pretty good, some hardware is awful. You'd have to measure your system to see how bad it drifts between polls.






                      share|improve this answer
























                      • More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

                        – Rui F Ribeiro
                        40 mins ago
















                      1














                      The full NTP client will attempt to modify the running clock's drift rate. If a client seems to be slow, it will speed it up. When successful, the clock remains more accurate between updates. Also (when running properly) all further updates are only by drift adjustment. It will not need to "jump" the clock.



                      Most SNTP clients will not attempt any modification of the drift rate. It simply sets the clock when a successful update runs. If the clock run rate is fast, these updates will require setting the clock backward, meaning it is possible for a specific time to occur more than once. In most end-user cases, these jumps will be small enough they don't cause a problem. But you should be aware they are possible. They are of course more likely if connectivity is disturbed for a long period of time.



                      So "accuracy" depends on the poll rate and the accuracy of the local oscillator. Some hardware is pretty good, some hardware is awful. You'd have to measure your system to see how bad it drifts between polls.






                      share|improve this answer
























                      • More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

                        – Rui F Ribeiro
                        40 mins ago














                      1












                      1








                      1







                      The full NTP client will attempt to modify the running clock's drift rate. If a client seems to be slow, it will speed it up. When successful, the clock remains more accurate between updates. Also (when running properly) all further updates are only by drift adjustment. It will not need to "jump" the clock.



                      Most SNTP clients will not attempt any modification of the drift rate. It simply sets the clock when a successful update runs. If the clock run rate is fast, these updates will require setting the clock backward, meaning it is possible for a specific time to occur more than once. In most end-user cases, these jumps will be small enough they don't cause a problem. But you should be aware they are possible. They are of course more likely if connectivity is disturbed for a long period of time.



                      So "accuracy" depends on the poll rate and the accuracy of the local oscillator. Some hardware is pretty good, some hardware is awful. You'd have to measure your system to see how bad it drifts between polls.






                      share|improve this answer













                      The full NTP client will attempt to modify the running clock's drift rate. If a client seems to be slow, it will speed it up. When successful, the clock remains more accurate between updates. Also (when running properly) all further updates are only by drift adjustment. It will not need to "jump" the clock.



                      Most SNTP clients will not attempt any modification of the drift rate. It simply sets the clock when a successful update runs. If the clock run rate is fast, these updates will require setting the clock backward, meaning it is possible for a specific time to occur more than once. In most end-user cases, these jumps will be small enough they don't cause a problem. But you should be aware they are possible. They are of course more likely if connectivity is disturbed for a long period of time.



                      So "accuracy" depends on the poll rate and the accuracy of the local oscillator. Some hardware is pretty good, some hardware is awful. You'd have to measure your system to see how bad it drifts between polls.







                      share|improve this answer












                      share|improve this answer



                      share|improve this answer










                      answered 44 mins ago









                      BowlOfRedBowlOfRed

                      2,620715




                      2,620715













                      • More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

                        – Rui F Ribeiro
                        40 mins ago



















                      • More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

                        – Rui F Ribeiro
                        40 mins ago

















                      More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

                      – Rui F Ribeiro
                      40 mins ago





                      More unpredictable and not so smooth jumps must be wonderful for system logs and DBs. ;-P

                      – Rui F Ribeiro
                      40 mins ago











                      1














                      As the other answer correctly states, chrony implements NTP and systemd-timesyncd SNTP.



                      From the point of view of a time service client:



                      SNTP is a much more simple protocol to implement;

                      NTP allows for step-by-step increments/corrections on time. One major advantage of NTP is that it also takes on account the RTT of the answer to get a more exact time.



                      From https://www.meinbergglobal.com/english/faq/faq_37.htm




                      While a full featured NTP server or client reaches a very high level
                      of accuracy and avoids abrupt time steps as much as possible by using
                      different mathematical and statistical methods and smooth clock speed
                      adjustments, SNTP can only be recommended for simple applications,
                      where the requirements for accuracy and reliability are not too
                      demanding. By disregarding drift values and using simplified ways of
                      system clock adjustment methods (often simple time stepping), SNTP
                      achieves only a low quality time synchronisation when compared with a
                      full NTP implementation.



                      SNTP adopts a much simpler approach. Many of the complexities of the
                      NTP algorithm are removed. Rather than skewing time, many SNTP clients
                      step time. This is fine for many applications where a simple
                      time-stamp is required. Additionally, SNTP lacks the ability to
                      monitor and filter multiple NTP servers. Often a simple round-robin
                      approach is used, where if one server fails, the next one in a list is
                      used




                      From https://www.masterclock.com/company/masterclock-inc-blog/ntp-vs-sntp




                      NTP is far more accurate and precise than SNTP, and this makes it the
                      de facto winner in most enterprise applications. On the other hand,
                      the simplicity of SNTP makes it more appropriate for things like IP
                      cameras, DVRs and some network switches. These types of hardware lack
                      the processing resources to handle more complex protocols, but as
                      connected devices become increasingly powerful, that may change.



                      One major weak point of SNTP is that you can't make it more accurate
                      by retrieving time from multiple sources like Network Time Protocol does by default.




                      One other major point I can see SNTP implementations giving more problems than NTP is in virtualisation, when you have both the hypervisor and NTP daemon trying to change the VM time. Specially with them not agreeing on time with some misconfiguration, it will cause big problems. (Whilst competent system administrators will try to disable the former, it can happen they are both active).



                      P.S. Obviously systemd-timesyncd is not an alternative when not using systemd.






                      share|improve this answer






























                        1














                        As the other answer correctly states, chrony implements NTP and systemd-timesyncd SNTP.



                        From the point of view of a time service client:



                        SNTP is a much more simple protocol to implement;

                        NTP allows for step-by-step increments/corrections on time. One major advantage of NTP is that it also takes on account the RTT of the answer to get a more exact time.



                        From https://www.meinbergglobal.com/english/faq/faq_37.htm




                        While a full featured NTP server or client reaches a very high level
                        of accuracy and avoids abrupt time steps as much as possible by using
                        different mathematical and statistical methods and smooth clock speed
                        adjustments, SNTP can only be recommended for simple applications,
                        where the requirements for accuracy and reliability are not too
                        demanding. By disregarding drift values and using simplified ways of
                        system clock adjustment methods (often simple time stepping), SNTP
                        achieves only a low quality time synchronisation when compared with a
                        full NTP implementation.



                        SNTP adopts a much simpler approach. Many of the complexities of the
                        NTP algorithm are removed. Rather than skewing time, many SNTP clients
                        step time. This is fine for many applications where a simple
                        time-stamp is required. Additionally, SNTP lacks the ability to
                        monitor and filter multiple NTP servers. Often a simple round-robin
                        approach is used, where if one server fails, the next one in a list is
                        used




                        From https://www.masterclock.com/company/masterclock-inc-blog/ntp-vs-sntp




                        NTP is far more accurate and precise than SNTP, and this makes it the
                        de facto winner in most enterprise applications. On the other hand,
                        the simplicity of SNTP makes it more appropriate for things like IP
                        cameras, DVRs and some network switches. These types of hardware lack
                        the processing resources to handle more complex protocols, but as
                        connected devices become increasingly powerful, that may change.



                        One major weak point of SNTP is that you can't make it more accurate
                        by retrieving time from multiple sources like Network Time Protocol does by default.




                        One other major point I can see SNTP implementations giving more problems than NTP is in virtualisation, when you have both the hypervisor and NTP daemon trying to change the VM time. Specially with them not agreeing on time with some misconfiguration, it will cause big problems. (Whilst competent system administrators will try to disable the former, it can happen they are both active).



                        P.S. Obviously systemd-timesyncd is not an alternative when not using systemd.






                        share|improve this answer




























                          1












                          1








                          1







                          As the other answer correctly states, chrony implements NTP and systemd-timesyncd SNTP.



                          From the point of view of a time service client:



                          SNTP is a much more simple protocol to implement;

                          NTP allows for step-by-step increments/corrections on time. One major advantage of NTP is that it also takes on account the RTT of the answer to get a more exact time.



                          From https://www.meinbergglobal.com/english/faq/faq_37.htm




                          While a full featured NTP server or client reaches a very high level
                          of accuracy and avoids abrupt time steps as much as possible by using
                          different mathematical and statistical methods and smooth clock speed
                          adjustments, SNTP can only be recommended for simple applications,
                          where the requirements for accuracy and reliability are not too
                          demanding. By disregarding drift values and using simplified ways of
                          system clock adjustment methods (often simple time stepping), SNTP
                          achieves only a low quality time synchronisation when compared with a
                          full NTP implementation.



                          SNTP adopts a much simpler approach. Many of the complexities of the
                          NTP algorithm are removed. Rather than skewing time, many SNTP clients
                          step time. This is fine for many applications where a simple
                          time-stamp is required. Additionally, SNTP lacks the ability to
                          monitor and filter multiple NTP servers. Often a simple round-robin
                          approach is used, where if one server fails, the next one in a list is
                          used




                          From https://www.masterclock.com/company/masterclock-inc-blog/ntp-vs-sntp




                          NTP is far more accurate and precise than SNTP, and this makes it the
                          de facto winner in most enterprise applications. On the other hand,
                          the simplicity of SNTP makes it more appropriate for things like IP
                          cameras, DVRs and some network switches. These types of hardware lack
                          the processing resources to handle more complex protocols, but as
                          connected devices become increasingly powerful, that may change.



                          One major weak point of SNTP is that you can't make it more accurate
                          by retrieving time from multiple sources like Network Time Protocol does by default.




                          One other major point I can see SNTP implementations giving more problems than NTP is in virtualisation, when you have both the hypervisor and NTP daemon trying to change the VM time. Specially with them not agreeing on time with some misconfiguration, it will cause big problems. (Whilst competent system administrators will try to disable the former, it can happen they are both active).



                          P.S. Obviously systemd-timesyncd is not an alternative when not using systemd.






                          share|improve this answer















                          As the other answer correctly states, chrony implements NTP and systemd-timesyncd SNTP.



                          From the point of view of a time service client:



                          SNTP is a much more simple protocol to implement;

                          NTP allows for step-by-step increments/corrections on time. One major advantage of NTP is that it also takes on account the RTT of the answer to get a more exact time.



                          From https://www.meinbergglobal.com/english/faq/faq_37.htm




                          While a full featured NTP server or client reaches a very high level
                          of accuracy and avoids abrupt time steps as much as possible by using
                          different mathematical and statistical methods and smooth clock speed
                          adjustments, SNTP can only be recommended for simple applications,
                          where the requirements for accuracy and reliability are not too
                          demanding. By disregarding drift values and using simplified ways of
                          system clock adjustment methods (often simple time stepping), SNTP
                          achieves only a low quality time synchronisation when compared with a
                          full NTP implementation.



                          SNTP adopts a much simpler approach. Many of the complexities of the
                          NTP algorithm are removed. Rather than skewing time, many SNTP clients
                          step time. This is fine for many applications where a simple
                          time-stamp is required. Additionally, SNTP lacks the ability to
                          monitor and filter multiple NTP servers. Often a simple round-robin
                          approach is used, where if one server fails, the next one in a list is
                          used




                          From https://www.masterclock.com/company/masterclock-inc-blog/ntp-vs-sntp




                          NTP is far more accurate and precise than SNTP, and this makes it the
                          de facto winner in most enterprise applications. On the other hand,
                          the simplicity of SNTP makes it more appropriate for things like IP
                          cameras, DVRs and some network switches. These types of hardware lack
                          the processing resources to handle more complex protocols, but as
                          connected devices become increasingly powerful, that may change.



                          One major weak point of SNTP is that you can't make it more accurate
                          by retrieving time from multiple sources like Network Time Protocol does by default.




                          One other major point I can see SNTP implementations giving more problems than NTP is in virtualisation, when you have both the hypervisor and NTP daemon trying to change the VM time. Specially with them not agreeing on time with some misconfiguration, it will cause big problems. (Whilst competent system administrators will try to disable the former, it can happen they are both active).



                          P.S. Obviously systemd-timesyncd is not an alternative when not using systemd.







                          share|improve this answer














                          share|improve this answer



                          share|improve this answer








                          edited 8 mins ago

























                          answered 46 mins ago









                          Rui F RibeiroRui F Ribeiro

                          40.9k1479137




                          40.9k1479137






























                              draft saved

                              draft discarded




















































                              Thanks for contributing an answer to Unix & Linux Stack Exchange!


                              • Please be sure to answer the question. Provide details and share your research!

                              But avoid



                              • Asking for help, clarification, or responding to other answers.

                              • Making statements based on opinion; back them up with references or personal experience.


                              To learn more, see our tips on writing great answers.




                              draft saved


                              draft discarded














                              StackExchange.ready(
                              function () {
                              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2funix.stackexchange.com%2fquestions%2f504381%2fchrony-vs-systemd-timesyncd-what-are-the-differences-and-use-cases-as-ntp-cli%23new-answer', 'question_page');
                              }
                              );

                              Post as a guest















                              Required, but never shown





















































                              Required, but never shown














                              Required, but never shown












                              Required, but never shown







                              Required, but never shown

































                              Required, but never shown














                              Required, but never shown












                              Required, but never shown







                              Required, but never shown







                              Popular posts from this blog

                              “%fieldName is a required field.”, in Magento2 REST API Call for GET Method Type The Next...

                              How to change City field to a dropdown in Checkout step Magento 2Magento 2 : How to change UI field(s)...

                              變成蝙蝠會怎樣? 參考資料 外部連結 导航菜单Thomas Nagel, "What is it like to be a...