<!doctype html>

<!--[if lt IE 7]><html lang="en-US" class="no-js lt-ie9 lt-ie8 lt-ie7"><![endif]-->
<!--[if (IE 7)&!(IEMobile)]><html lang="en-US" class="no-js lt-ie9 lt-ie8"><![endif]-->
<!--[if (IE 8)&!(IEMobile)]><html lang="en-US" class="no-js lt-ie9"><![endif]-->
<!--[if gt IE 8]><!-->
<html lang="en-US" class="no-js">
    <!--<![endif]-->

    <head>
        <meta charset="utf-8">

        <meta http-equiv="X-UA-Compatible" content="IE=edge">

        <title>Apache Spot Blog</title>

        <meta name="HandheldFriendly" content="True">
        <meta name="MobileOptimized" content="320">
        <meta name="viewport" content="width=device-width, initial-scale=1"/>

        <link rel="apple-touch-icon" href="../library/images/apple-touch-icon.png">
        <link rel="icon" href="../favicon.png">
        <!--[if IE]>
        <link rel="shortcut icon" href="http://spot.incubator.apache.org/favicon.ico">
        <![endif]-->
        <meta name="msapplication-TileColor" content="#f01d4f">
        <meta name="msapplication-TileImage" content="../library/images/win8-tile-icon.png">
        <meta name="theme-color" content="#121212">

        <link rel='dns-prefetch' href='//fonts.googleapis.com' />
        <link rel='dns-prefetch' href='//s.w.org' />
        <link rel="alternate" type="application/rss+xml" title="Apache Spot &raquo; Feed" href="../feed/" />

        <link rel='stylesheet' id='googleFonts-css'  href='http://fonts.googleapis.com/css?family=Lato%3A400%2C700%2C400italic%2C700italic' type='text/css' media='all' />
        <link rel='stylesheet' id='bones-stylesheet-css'  href='../library/css/style.css' type='text/css' media='all' />
        <!--[if lt IE 9]>
        <link rel='stylesheet' id='bones-ie-only-css'  href='http://spot.incubator.apache.org/library/css/ie.css' type='text/css' media='all' />
        <![endif]-->
        <link rel='stylesheet' id='mm-css-css'  href='../library/css/meanmenu.css' type='text/css' media='all' />
        <script type='text/javascript' src='../library/js/libs/modernizr.custom.min.js'></script>
        <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.1/jquery.min.js"></script>
        <script type='text/javascript' src='../library/js/jquery-migrate.min.js'></script>
        <script type='text/javascript' src='../library/js/jquery.meanmenu.js'></script>

		<script>
		  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

		  ga('create', 'UA-87470508-1', 'auto');
		  ga('send', 'pageview');

		</script>
    </head>

    <body class="blog">

        <div id="container">
            <header class="header">

                <div id="inner-header" class="wrap cf">

                    <p id="logo" class="h1" itemscope itemtype="http://schema.org/Organization">
                        <a href="http://spot.incubator.apache.org/" rel="nofollow"><img src="../library/images/logo.png" alt="Apache Spot" /></a>
                    </p>

                    <nav>
                        <ul id="menu-main-menu" class="nav top-nav cf">
                          <li id="menu-item-129" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-129">
                              <a href="../get-started">Get Started</a>
                              <ul class="sub-menu">
                                <li><a href="../get-started">Get Started</a></li>
                                <li><a href="../get-started/supporting-apache">Supporting Apache</a></li>
                                <li><a href="../get-started/environment">Environment</a></li>
                                <li><a href="../get-started/architecture">Architecture</a></li>
                                <li><a href="../get-started/demo">Demo</a></li>
                              </ul>
                            </li>
                            <li id="menu-item-5" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-5">
                                <a href="../download">Download</a>
                            </li>
                            <li id="menu-item-130" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-130">
                                <a href="../community">Community</a>
                                <ul class="sub-menu com-sm">
                                	<li class="dropmenu-head">Get in Touch</li>
                                	<li><a href="../community" class="mail">Mailing Lists</a></li>
                                	<li class="divider"></li>
                                	<li><a href="../community/committers">Project Committers</a></li>
                                	<li><a href="../community/contribute">How to Contribute</a></li>
                                	<li class="divider"></li>
                                	<li class="dropmenu-head">Developer Resources</li>
                                	<li><a href="https://github.com/apache/incubator-spot" target="_blank" class="github">Github</a></li>
                                	<li><a href="https://issues.apache.org/jira/browse/SPOT/" target="_blank" class="jira">JIRA Issue Tracker</a></li>
<li><a href="https://cwiki.apache.org/confluence/pages/viewpage.action?spaceKey=SPOT&title=Apache+Spot+%28Incubating%29+Home" target="_blank" class="">Confluence Site</a></li>                                	<li class="divider"></li>
                                	<li class="dropmenu-head">Social Media</li>
                                	<li><a href="https://twitter.com/ApacheSpot" target="_blank" class="twitter-icon">Twitter</a></li>
                                </ul>
                            </li>
                            <li id="menu-item-106" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-106">
                                <a href="http://spot.incubator.apache.org/doc">Documentation</a>
                            </li>
                            <li class="menu-item menu-item-has-children">
                                <a href="#">Project Components</a>
                                <ul class="sub-menu">
                                	<li><a href="../project-components/ingestion">Ingestion</a></li>
                                	<li><a href="../project-components/machine-learning">Machine Learning</a></li>
                                  <li><a href="../project-components/suspicious-connects-analysis">Suspicous Connects Analysis</a></li>
                                	<li><a href="../project-components/visualization">Visualization</a></li>
                                  <li class="under-dev">Under Development</li>
                                  <li><a href="../project-components/open-data-models">Open Data Models</a></li>
                                </ul>
                            </li>
                            <li id="menu-item-13" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-13 active">
                                <a href="../blog">Blog</a>
                            </li>
                        </ul>
                    </nav>

                </div>

            </header>

            <div id="mobile-nav"></div>

            <div id="content">

                <div id="inner-content" class="wrap cf">
                    <main id="main" class="m-all t-2of3 d-5of7 cf" role="main" itemscope itemprop="mainContentOfPage" itemtype="http://schema.org/Blog">

                        <article class="cf post type-post status-publish format-standard hentry category-security-analytics tag-github tag-open-network-insight tag-open-source" role="article">

                            <header class="entry-header article-header">

                                <h3 class="h2 entry-title"><a href="../blog/apache-spot-product-architecture-overview/" rel="bookmark" title="Apache Spot: Three Most-Asked Questions">Apache Spot Product Architecture Overview</a></h3>
                                <p class="byline entry-meta vcard">
                                    <time class="updated entry-time" datetime="2017-03-27" itemprop="datePublished">
                                        March 27, 2017
                                    </time>
                                    </span>
                                </p>

                            </header>

                            <section class="entry-content cf">

                                <p>Data Sources - Spot can directly collect netflow data, DNS data and/or proxy data. This data can be collected also from a SIEM or from a common logging server. Additional data types can be collected using Open Data Model. Any number of data sources can be analyzed using Spot. Because most of these data sources represent a large volume of data, most organizations start with the data source that represents the area of highest risk.&#8230; <a class="excerpt-read-more" href="../blog/apache-spot-product-architecture-overview/" title="Read Apache Spot Product Architecture Overview">Read more &raquo;</a></p>

                            </section>

                            <footer class="article-footer">

                            </footer>

                        </article>

                        <article id="post-149" class="cf post-149 post type-post status-publish format-standard hentry category-uncategorized" role="article">

                            <header class="article-header">

                                <h1 class="h2 entry-title"><a href="strength-in-numbers-why-consider-open-source-cybersecurity-analytics/" rel="bookmark" title="Strength in Numbers:  Why Consider Open Source Cybersecurity Analytics">Strength in Numbers:  Why Consider Open Source Cybersecurity Analytics</a></h1>
                                <p class="byline entry-meta vcard">
                                    <time class="updated entry-time" datetime="2016-10-21" itemprop="datePublished">
                                        October 21, 2016
                                    </time>
                                    </span>
                                </p>

                            </header>

                            <section class="entry-content cf">
                                <div class="m-all t-1of4 d-2of7"></div>
                                <div class="m-all t-3of4 d-5of7">
                                    <p>
                                        By Rob Kent, Vice President of Marketing at Cybraics Competition is widely considered to be a healthy and positive thing, traditionally viewed as providing options for customers and fueling innovation. In the world of cybersecurity there is no shortage of competition, in fact cybersecurity is one of the most crowded and fast-growing areas of technology&#8230;. <a class="excerpt-read-more" href="strength-in-numbers-why-consider-open-source-cybersecurity-analytics/" title="Read Strength in Numbers:  Why Consider Open Source Cybersecurity Analytics">Read more &raquo;</a>
                                    </p>
                                </div>
                            </section>

                        </article>

                        <article id="post-136" class="cf post-136 post type-post status-publish format-standard hentry category-uncategorized" role="article">

                            <header class="article-header">

                                <h1 class="h2 entry-title"><a href="jupyter-notebooks-for-data-analysis" rel="bookmark" title="Jupyter Notebooks for Data Analysis">Jupyter Notebooks for Data Analysis</a></h1>
                                <p class="byline entry-meta vcard">
                                    <time class="updated entry-time" datetime="2016-09-22" itemprop="datePublished">
                                        September 22, 2016
                                    </time>
                                    </span>
                                </p>

                            </header>

                            <section class="entry-content cf">
                                <div class="m-all t-1of4 d-2of7"></div>
                                <div class="m-all t-3of4 d-5of7">
                                    <p>
                                        Why Does Apache Spot Include iPython notebooks? The project team wants Apache Spot to be a versatile tool that can be used by anyone. This means that data scientists and developers need to be able to query and handle the source data to find all the information they need for their decision making. The&#8230; <a class="excerpt-read-more" href="jupyter-notebooks-for-data-analysis/" title="Read Jupyter Notebooks for Data Analysis">Read more &raquo;</a>
                                    </p>
                                </div>
                            </section>

                        </article>

                        <article id="post-117" class="cf post-117 post type-post status-publish format-standard hentry category-cybersecurity" role="article">

                            <header class="article-header">

                                <h1 class="h2 entry-title"><a href="apache-spot-and-cybersecurity-using-netflows-to-detect-threats-to-critical-infrastructure/" rel="bookmark" title="Apache Spot and Cybersecurity — Using NetFlows to Detect Threats to  Critical Infrastructure">Apache Spot (Incubating) and Cybersecurity — Using NetFlows to Detect Threats to  Critical Infrastructure</a></h1>
                                <p class="byline entry-meta vcard">
                                    <time class="updated entry-time" datetime="2016-08-08" itemprop="datePublished">
                                        August 8, 2016
                                    </time>
                                    </span>
                                </p>

                            </header>

                            <section class="entry-content cf">
                                <div class="m-all t-1of4 d-2of7"></div>
                                <div class="m-all t-3of4 d-5of7">
                                    <p>
                                        The “first” documented cybersecurity case was the worm replication, which was initiated by Robert T. Morris on November 2, 1988. Wow! Here we are in 2016, 28 years later, with viruses and worms giving way to Trojan horses and polymorphic code. Nowadays, we are also fighting against DDoS, phishing, spear phishing attacks, command and controls&#8230; <a class="excerpt-read-more" href="apache-spot-and-cybersecurity-using-netflows-to-detect-threats-to-critical-infrastructure/" title="Read Apache Spot and Cybersecurity — Using NetFlows to Detect Threats to  Critical Infrastructure">Read more &raquo;</a>
                                    </p>
                                </div>
                            </section>

                        </article>

                        <article id="post-113" class="cf post-113 post type-post status-publish format-standard hentry category-uncategorized" role="article">

                            <header class="article-header">

                                <h1 class="h2 entry-title"><a href="how-apache-spot-helps-create-well-stocked-data-lakes-and-catch-powerful-insights/" rel="bookmark" title="How Apache Spot Helps Create Well-Stocked Data Lakes and Catch Powerful Insights">How Apache Spot (Incubating) Helps Create Well-Stocked Data Lakes and Catch Powerful Insights</a></h1>
                                <p class="byline entry-meta vcard">
                                    <time class="updated entry-time" datetime="2016-08-08" itemprop="datePublished">
                                        August 8, 2016
                                    </time>
                                    </span>
                                </p>

                            </header>

                            <section class="entry-content cf">
                                <div class="m-all t-1of4 d-2of7"></div>
                                <div class="m-all t-3of4 d-5of7">
                                    <p>
                                        About four years ago, the era of the Big Data analytics began. Paired with advanced analytics, massive volumes of data can be culled to not only inform critical decisions, but also to simulate sophisticated “what if” scenarios that allow companies to gain competitive advantages by generating and predicting different scenarios. For example, a financial services&#8230; <a class="excerpt-read-more" href="how-apache-spot-helps-create-well-stocked-data-lakes-and-catch-powerful-insights/" title="Read How Apache Spot Helps Create Well-Stocked Data Lakes and Catch Powerful Insights">Read more &raquo;</a>
                                    </p>
                                </div>
                            </section>

                        </article>

                        <article id="post-62" class="cf post-62 post type-post status-publish format-standard hentry category-security-analytics tag-github tag-apache-spot tag-open-source" role="article">

                            <header class="article-header">

                                <h1 class="h2 entry-title"><a href="apache-spot-3-most-asked-questions/" rel="bookmark" title="Apache Spot: Three Most-Asked Questions">Apache Spot (Incubating): Three Most-Asked Questions</a></h1>
                                <p class="byline entry-meta vcard">
                                    <time class="updated entry-time" datetime="2016-03-29" itemprop="datePublished">
                                        March 29, 2016
                                    </time>
                                    </span>
                                </p>

                            </header>

                            <section class="entry-content cf">
                                <div class="m-all t-1of4 d-2of7"></div>
                                <div class="m-all t-3of4 d-5of7">
                                    <p>
                                        While this is not the first blog post about Apache Spot, it is the first one by a creator of the solution. As a security data scientist in Intel&#8217;s Data Center Group, I joined a small team to start thinking about solving really hard problems in cloud analytics. The team grew, and out of that&#8230; <a class="excerpt-read-more" href="apache-spot-3-most-asked-questions/" title="Read Apache Spot: Three Most-Asked Questions">Read more &raquo;</a>
                                    </p>
                                </div>
                            </section>

                        </article>

                    </main>

					<div id="sidebar1" class="sidebar m-all t-1of3 d-2of7 last-col cf" role="complementary">

						<div id="recent-posts-2" class="widget widget_recent_entries">
							<h4 class="widgettitle">Recent Posts</h4>
							<ul>
								<li>
									<a href="../blog/apache-spot-product-architecture-overview/">Apache Spot Product Architecture Overview</a>
								</li>
								<li>
									<a href="../blog/strength-in-numbers-why-consider-open-source-cybersecurity-analytics/">Strength in Numbers:  Why Consider Open Source Cybersecurity Analytics</a>
								</li>
								<li>
									<a href="../blog/jupyter-notebooks-for-data-analysis/">Jupyter Notebooks for Data Analysis</a>
								</li>
								<li>
									<a href="../blog/apache-spot-and-cybersecurity-using-netflows-to-detect-threats-to-critical-infrastructure/">Apache Spot (Incubating) and Cybersecurity — Using NetFlows to Detect Threats to  Critical Infrastructure</a>
								</li>
								<li>
									<a href="../blog/how-apache-spot-helps-create-well-stocked-data-lakes-and-catch-powerful-insights/">How Apache Spot (Incubating) Helps Create Well-Stocked Data Lakes and Catch Powerful Insights</a>
								</li>
								<li>
									<a href="../blog/apache-spot-3-most-asked-questions/">Apache Spot (Incubating): 3 Most-Asked Questions</a>
								</li>
							</ul>
						</div>
						<div id="archives-2" class="widget widget_archive">
							<h4 class="widgettitle">Archives</h4>
							<ul>
								<li>
									<a href='../2017/03/'>March 2017</a>
								</li>
								<li>
									<a href='../2016/10/'>October 2016</a>
								</li>
								<li>
									<a href='../2016/09/'>September 2016</a>
								</li>
								<li>
									<a href='../2016/08/'>August 2016</a>
								</li>
								<li>
									<a href='../2016/03/'>March 2016</a>
								</li>
							</ul>
						</div>

					</div>

                </div>

            </div>

            <footer class="footer" role="contentinfo" itemscope itemtype="http://schema.org/WPFooter">

                <div id="inner-footer" class="wrap cf">

                    <p class="source-org copyright" style="text-align:center;">
                        &copy; 2019 Apache Spot.
                    </p>

                </div>

            </footer>

        </div>
		<a href="#0" class="cd-top">Top</a>
        <script type='text/javascript' src='../library/js/scripts.js'></script>

    </body>

</html>
